Week 5 · 41039 Programming 1

Classes, Objects and Enums

Week 4 split a program into methods. This week the methods get something to belong to: objects, bundles of data together with the code allowed to touch it, built from classes. You will write your own classes in Java and Python, see what new and this really do, meet enums — types with a fixed set of values — and see what Java’s switch has grown into since Week 2.

5 Ed lessons Java Python

BankAccount.java

public class BankAccount {

    private String customerName;
    private double balance;

    public BankAccount(String name, double start) {
        this.customerName = name;
        this.balance = start;
    }

    public void deposit(double amount) {
        if (amount > 0) this.balance += amount;
    }
}

Week 5 · Interactive

The lecture, then the practice

Choose a section from the list to open it — or use the arrow keys once the list has focus. Every code example explains itself: hover over an underlined part (or tap it) to see what it does. Run runs it; ✎ Edit opens it in an editor to change it and break it on purpose. Several are meant to fail — read what the compiler says before you fix them.

01The ideas behind OOP

1.1A brief history

Object-oriented programming (OOP) is a broad family of ways to design programs, centred on one idea: bind data to the code that is allowed to manipulate it, in a single entity called an object.

Historically the idea grew, possibly ironically, out of the functional language Lisp in the late 1950s and early 1960s. Simula introduced many of the concepts still in C++ and Java — classes, dynamic binding, inheritance — with syntax close to Algol 60, which is why it reads fairly easily to a Java programmer. Smalltalk was designed as an OO language from the ground up and is often called the first “true” one, but Simula has had the greater effect so far — not least because Bjarne Stroustrup used it during his doctoral work and then built its ideas into C++.

The class concept allowed me to map my application concepts into the language constructs in a direct way that made my code more readable than I had seen in any other language.

Bjarne Stroustrup, A History of C++: 1979–1991, HOPL-II, 1993 — on writing his PhD simulator in Simula Portrait: Victor Zavyalov / ICPCNews, 2013 · CC BY 2.0

OOP became the dominant paradigm in the 1990s, with C++, the arrival of Java, and a software industry that needed modular, reusable, maintainable programs at large scale. Like any tool it can be used badly; used well, it is a very powerful way to build large software that can be extended without being rewritten.

Did you know?

Two Turing Awards in three years went to object orientation. The 2001 award went to Ole-Johan Dahl and Kristen Nygaard “for ideas fundamental to the emergence of object-oriented programming, through their design of the programming languages Simula I and Simula 67”; the 2003 award to Alan Kay for “leading the team that developed Smalltalk”, among other things. Both Stroustrup and James Gosling, Java’s creator, have named Simula as a major influence. Source: Wikipedia — Turing Award and Simula.

Kristen Nygaard, co-designer of Simula, photographed in 1997 — Kristen Nygaard. Photo: Jorge Stolfi, 1997 · public domain

1.2The four pillars

“Object-oriented” covers anything whose fundamental unit is the object, but almost every OO language rests on four principles:

Pillar	What it means
Encapsulation	Data is enclosed in objects. That gives it context, and control over how it is accessed and changed.
Abstraction	Implementation details are hidden from the outside. Two implementations that do the same job are interchangeable; users only deal with the abstraction.
Inheritance	Objects can inherit properties from other objects, so subtypes exist, share what they have in common and differ only where they need to.
Polymorphism	One thing, many “shapes”: different implementations of the same method, objects with several types, type information abstracted away.

They are not completely separate — encapsulation enables abstraction, inheritance supports polymorphism, polymorphism supports abstraction. Under all four sits a vaguer but stronger idea, shared with the modular programming that came before OOP: any unit of a program should not have to care how the rest of the program works in order to work correctly.

1.3Encapsulation

The simplest pillar to get hold of, though its payoff only really shows when you build something large or fix someone else’s code. This BankAccount (the one from lab 5) encapsulates two pieces of data and offers methods for controlled access to them. The balance is kept as a whole number of cents:

new makes a BankAccount object and runs its constructor (lines 20–23) with these two arguments. The f makes 100.10 a float literal; without it, it is a double and will not fit the float parameter.
main learns the balance only by calling a public method, which returns it as a float number of dollars. Nothing in main reveals that the account keeps cents.
Each call rounds 0.01 × 100 to exactly 1 cent, so the int balance grows by exactly 1000 cents, to $1,000,010. Keep this loop in mind for 1.4.
The blueprint for every account object: two pieces of data (lines 17–18) together with the only methods allowed to touch them. Binding data to the code allowed to change it is the central idea of OOP (1.1).
Only code inside BankAccount may use accountName, or balance on line 18, which is private too. Runner’s main is outside, so it must go through the public methods.
An int holds whole numbers exactly, so $100.10 is kept as 10010 and adding or subtracting cents never loses anything to rounding.
Same name as the class and no return type, not even void. It runs once, when new creates the object, and gives the fields their first values.
The parameter has the same name as the field, so plain accountName means the parameter. this.accountName is the field of the object being built.
Multiply to get cents, still a float, then round to the nearest whole number. Given a float, Math.round returns an int, so the result goes into balance with no cast.
The cast applies to this.balance alone, so the division is done in float and keeps the cents: 11919 becomes 119.19. Without the cast, int division would give 119.
The amount is turned into whole cents before it is subtracted. No parameter is called balance, so the plain name means the field; this. is optional here.
A method may share a field’s name; the brackets tell Java which is meant. It hands out the name, and no method changes it, so outside code can read the name but never alter it.

Two classes in one file: only one may be public, and the file is named after it — the Week 1 rule. BankAccount has no access modifier, which is what lets it share the file.

accountName and balance are private, so code outside the class cannot interfere with them except through the methods. Try it: this main reaches for the balance directly.

The constructor is public, so any class may create an account. But a compile error stops the whole file, so not even this line runs.
main is in Runner, and balance is private to BankAccount, so the compiler refuses the assignment (javac: balance has private access in BankAccount). Sharing a file does not help: private means this class only.
This cut-down class has only a constructor. With no public methods, code outside the class cannot read or change balance at all.
Access to balance is limited to code written inside BankAccount’s braces. Remove this word and line 4 compiles — and main can set any balance it likes.
The constructor belongs to BankAccount, so it may assign balance freely. The same field is out of bounds in main.

Safety, not security

private is there to stop accidental interference, not a determined attacker. It is about safety, and a step towards abstraction: code that uses BankAccount never needs to know how the data is stored inside, only which public methods it can call.

1.4Abstraction — and we tested the claim

Abstraction says you should not have to care about the insides of something when they do not matter to what it does. A clockwork watch, a digital watch and a phone all present the time; you use them interchangeably whether there are gears inside or a connection to an atomic clock.

For code, that means the rest of a program should not have to change when an implementation does. The Ed lesson offers a second BankAccount that stores a float instead of cents, and says the lab program could “probably (I haven’t tested it)” use it unchanged. So test it. Same main, word for word; only the inside of BankAccount differs:

main depends only on the names, parameters and return types of the constructor and the four public methods. Those are identical, so main compiles without a change.
In the cents version this loop added exactly 1000 cents. Here each call does a float addition that changes nothing (line 34), so Bach’s balance never moves from 1000000.0.
The field now holds dollars directly, as a float. Because it is private, no code outside the class could depend on it — which is why the swap is invisible to main.
No conversion to cents. But 100.10f cannot be held exactly: the nearest float is 100.09999847…, which currentBalance later rounds back to the cent.
Turns dollars into cents and rounds to the nearest whole number. Given a float, Math.round returns an int.
The cast applies to the int from Math.round, so / 100 divides in float and keeps the cents. Without it, int division would drop them.
Each subtraction and addition rounds its result to the nearest float. Near Linh’s 100 dollars those errors are far below a cent, and currentBalance rounds them away.
Near 1,000,000 the nearest floats are 1000000.0 and 1000000.0625. The exact sum, about 1000000.01, is much closer to the first, so the result rounds back to the old balance.

Linh’s account agrees with the cents version, to the cent. Bach’s does not: a thousand one-cent deposits into a million-dollar account simply vanish. A Java float is an IEEE 754 32-bit number with only about seven significant digits, and near 1,000,000 the gap between one float and the next is 0.0625 — so adding 0.01 rounds straight back to where it started.

What abstraction does and does not promise

The swap worked exactly as abstraction says it should: main compiled and ran without a single change. What abstraction cannot do is make the new implementation correct. That is why the Java lesson suggests storing money as an int number of cents — and why “I haven’t tested it” is a sentence worth never leaving in your own code.

1.5Inheritance and polymorphism, briefly

Inheritance arrives properly in the next few lessons. In Java it comes in two forms, class-based inheritance and interfaces, and it does two jobs at once: a child class reuses its parent’s data and methods instead of reimplementing them, and a child can be treated as the same kind of thing as its parent.

Polymorphism comes in three basic forms:

Ad-hoc — the same method name applied to different parameter lists. You have used it constantly: it is Week 4’s overloading, and the reason System.out.println has ten versions.
Parametric — type information abstracted out, so code can store or move objects without caring much what type they are. Coming very soon.
Sub-type — an object can be treated as having the type of any of its parent classes. Also coming very soon.

02Classes and objects in Java

2.1The dot operator, said out loud

A piece of syntax you have been using quietly since Week 1: ., said “dot”. It takes the thing on its left and retrieves the member inside it named on its right.

Code	What the dots do
System.out.println("Hi")	look in the class `System` for the class-level variable `out` (a `PrintStream` — Week 4, 3.3); in that object find the method `println(String)`, and run it with `"Hi"`
sc.nextInt()	go to the object that the variable `sc` refers to, find its method `nextInt()`, and run it with no arguments

A dot gives you either a value (reading a variable) or a method (which then runs straight away). Because an object variable holds a reference — Week 4, section 6.3 — the dot is sometimes called the dereference operator: it follows the reference to the object. Beyond that there is nothing special about it; it just gets things out of other things.

2.2Classes are templates for objects

An object is a construct that encapsulates data and offers methods to interact with it. An OO language needs a way to define objects — what data they hold, what methods they have — and Java is class-based (as opposed to prototype-based): a class is the template for its objects.

<access modifier> class <Name> {
    <data and methods>
}

Access modifiers are the ones you know from methods. Classes are almost always public for now — and each .java file can have only one public class, named the same as the file.
Class names follow the variable rules, but start with an upper-case letter: Scanner, String, BankAccount.

An empty class is perfectly legal, and occasionally handy as a placeholder to fill in later. Empty here has no access modifier at all:

Only one class per file may be public, and the file must be named after it — Runner.java. It holds main, so this is where the program starts.
The variable’s type is the class Empty. Java is case-sensitive, so Empty and empty are different names; by convention only the class starts with a capital.
The class is only the template; new makes an actual object from it and gives back a reference, stored in empty. It works although Empty declares no constructor, because Java supplies a default one (section 4.2).
With no public, Empty can share Runner’s file. Its body holds no data and no methods, yet the class is legal and usable as a type.

One class, one purpose

A class should have a single clear purpose: it models one entity in the system. What counts as one entity depends on the system, and gets clearer with practice — but it is usually obvious what does not belong. A class modelling a bank account should not also store the staffing details of a branch.

2.3A class with data and methods

A bank account should know whose it is and how much is in it, and offer ways to read and change that. Both the data and the methods are members of the class:

new creates a fresh BankAccount object and runs its constructor (line 22) with these two arguments. The reference that comes back is stored in acc.
The inner call runs first: nextDouble() reads 50 and returns it as a double. Then the dot follows acc to its object and runs that object’s deposit with 50.0 as amount.
main can only ask the account for 500; withdraw decides. The balance is 150.0, so the request is refused and nothing tells the caller.
The fields are private, so main cannot write acc.customerName; it calls a method that returns the value instead. A method used like this is often called a getter.
No main and nothing static: the class only describes what every account holds and can do. Nothing happens until another class makes an object from it.
Every BankAccount object gets its own customerName and balance. private means only code inside this class can use them by name.
Named after the class, with no return type — not even void. It runs once, when new makes the object, to give the fields their starting values; section 4.2 covers it fully.
this.customerName is the object’s field; plain customerName is the parameter of the same name. The parameter’s value is copied into the field (more in section 4.3).
A void method that modifies the object instead of returning a value — Week 4’s rule that a method normally does one or the other.
Both must hold: enough money, and a positive amount. Because balance is private, this method is the only way to reduce it, so no caller can skip the check.
The other half of that rule: getBalance hands back the current balance and leaves it alone. Line 13 joins it onto the string, giving Linh has 150.0.

With 50 then 500, the withdrawal is quietly refused — the rule lives inside the class, so no caller can forget it. The class has all the fundamental elements:

Data members, declared private so that only objects of this class can reach them. What could go wrong if they were public?
Method members, which allow controlled access to the data.

And notice what is missing: none of these members is static, and there is no main. BankAccount cannot do anything by itself — you create objects to hold the data, and other classes build them into a program. An OO program works through the interactions of classes and objects.

A simplified example

A real version would want an AccountHolder class instead of a bare name, would store cents rather than a double (section 1.4), and would say what happens when a withdrawal fails — and it is probably not this class’s job to validate amounts at all.

2.4Classes are types

A class is not only a template: it is a type. A variable’s type can be a class, and so can the element type of an array, the return type of a method and the type of a parameter. That buys real confidence:

The class name is used just like int in int[]: every element of accounts must be a reference to a BankAccount (or null).
This makes the array only — no BankAccount objects. Every slot starts as null until an account made with new BankAccount(…) is stored in it.

Nothing that is not a BankAccount can get into accounts — the compiler (or, failing that, the runtime) stops it. And because an object can be handed to a method, you can pass in functionality, not just data: below, countSameOwner does not pull the names out and compare them itself; it asks the account, because the account knows what “same owner” means.

One account and an array of them. Only BankAccounts can be passed in, so the compiler knows each one offers a hasSameOwner method.
candidate refers to each account in the array in turn — the objects themselves, not copies, since the array holds references.
The method does not pull the names out (it could not: they are private). It asks account, passing the candidate, and the boolean it gets back is the condition.
Three null references until lines 15–17 store an account in each.
Each new makes a separate account, and its reference goes into one slot. The int 100 is widened to the constructor’s double automatically.
Both arguments are references (Week 4, section 7), so the method works on the very same account and array. The first account is in the array too and matches itself, so the count is 2.
A method of the account itself: this is the account it was called on (account on line 6) and other is the one passed in.
equals compares the characters and returns a boolean; == only asks whether both are the same String object (section 4.4). Here == would happen to work, as identical literals share one object — names read from input would not.
Reading another account’s private field is allowed, because this code is inside BankAccount. The same expression in Runner would not compile.

Two details: hasSameOwner may read other.customerName even though it is private, because private means “only code in this class”, not “only this object”. And Strings are compared with .equals, not == — section 4.4 shows why. The Ed lesson’s own version of this method returns a List, which you have not met in Java yet; it is the same idea.

Now try to put something else in the array:

Every slot of accounts may hold only a BankAccount reference (or null), and the compiler checks each assignment into it before anything runs.
A BankAccount into a BankAccount slot. The class writes no constructor, so Java’s default one, with no parameters, is used (section 4.2).
The compiler checks the right-hand side against the element type and refuses. ECJ: Type mismatch: cannot convert from String to BankAccount; Ed’s javac: incompatible types: String cannot be converted to BankAccount.
No fields and no methods, yet BankAccount is a type the compiler enforces as strictly as int or String. Because of line 5, nothing runs — not even line 4.

03static: the class itself

3.1One copy, shared by every object

Objects quickly become the main actors in a Java program, but the class is still a thing in its own right. Anything marked static lives on the class: it exists without any objects, and it is not copied into objects at all. Reach a static variable through an object and you get the one class-level copy that every object shares:

The variable belongs to the class Silly itself. It is created and set to 10 before main even starts, with no object in existence, and it is never copied into objects.
a and b refer to two separate objects, but Silly has no instance variables, so neither object holds a value of its own.
The compiler uses only the type of a, Silly, to find the field — the one class-level value, still 10. The object itself plays no part.
There is no “b’s value” to change: this assigns 30 to the single shared copy, exactly as Silly.value = 30 would.
Now 30, although nothing was done to a: a.value and b.value are two names for one variable.
ClassName.member says plainly that the variable is static. It needs no object at all: Silly.value works even in a program that never says new Silly().

The Java Language Specification: for a static field “there exists exactly one incarnation of the field, no matter how many instances (possibly zero) of the class may eventually be created”. If every object of a class should share one value, this is how; it is also how to define program-wide constants, as static final — like the pizzas array in Week 4’s pizza shop.

Legal, but misleading

a.value looks as though it belongs to a. It does not. Write Silly.value for static members, so the code says what is really happening.

3.2Static methods

The class also provides all the static methods. main is the obvious one — it runs first, before any object exists. But any method that needs nothing beyond its parameters (and other static data) can be static and used without creating an object:

No static, so every Circle object gets its own x, y and radius (three declared in one statement). They have no memory until an object is made.
static: one copy, on the class; final: it can never change; public: other classes may read it as Circle.PI. Capitals are the naming convention for constants.
It would run once for each new Circle(…), copying its arguments into that object’s variables. main never creates a Circle, so it never runs in this program.
No static: it runs for one particular circle, so it can read that circle’s radius. It would be called on an object, as c.area().
An instance method may call a static one freely. One double argument matches area(double) on line 17, not this method itself: overloading again.
The static area uses nothing but its parameter and the static PI, so it needs no object. Its radius is the parameter, a new local variable, not any circle’s field.
main is static too, so it calls the static area directly. The int 5 is widened to 5.0 to fit double radius; area() takes no arguments, so it is not a candidate.

x, y and radius need an object before they have any memory or value, but the static constant PI and the static area(double) can be used with no Circle in existence. The instance method area() simply hands its own radius to the static one — two methods called area, told apart by their parameter lists: Week 4’s overloading again.

Java also provides a far better π as the static constant Math.PI — another class used without ever creating an object of it.

3.3What a static method cannot see

A static method runs on the class, with no particular object — so there is no radius for it to read. The compiler says so:

An instance variable: it exists only inside a Circle object, one copy per object, and only once that object has been created.
The constructor would give one circle its radius, but main never calls new Circle(…). Even if the compiler allowed line 10, there would be no radius to read.
A static method runs on the class itself, not for any particular circle, so there is no this — and no object whose variables it could read.
Static code naming an instance variable. The compiler rejects each use of radius on this line: this console says Cannot make a static reference to the non-static field radius; javac says non-static variable radius cannot be referenced from a static context.
Calling a static method from main is fine; the trouble is inside area. Either drop static and call new Circle(5).area(), or give area a parameter, like the static area(double radius) in the previous example.

Member	Lives on	Needs an object?	Can use
`static` variable	the class — one copy	no	—
instance variable	each object — one copy per object	yes	—
`static` method	the class	no: `Circle.area(5)`	its parameters and static members only
instance method	the class, run for one object	yes: `c.area()`	everything, including that object’s variables via `this`

This is the same rule as Week 4’s Cannot make a static reference to the non-static method, now for a variable.

04Constructors, `this`, and objects in memory

4.1What an object is, in memory

In Java all objects are created dynamically, so they always live on the heap (Week 4, section 6.3). A new object gets space only for the class’s non-static variables, plus a little bookkeeping. The methods, the static variables and everything else shared by all objects of the class are stored once, with the class — the JVM specification calls that area the method area, which stores “per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors”.

An object variable is then just a reference to where that data sits on the heap — which is exactly what made Week 4’s arrays behave as they did when passed to methods.

After new Circle(6, 7, 3) and new Circle() in section 4.3: two objects, each with its own four variables, and one class holding the shared PI and the code of every method. (Each colour is itself a reference, to a String elsewhere on the heap.)

4.2`new` and constructors

You have written this line in every program that reads input:

The type is the class Scanner and the name is sc. The variable will hold a reference to a Scanner object on the heap, not the object itself.
new asks the JVM for enough heap memory for one Scanner, then runs a constructor on it. The whole expression’s value is the reference to the new object, which is stored in sc.
The class name with an argument list chooses the constructor. System.in is the program’s standard input stream, so this is the Scanner constructor that takes an input stream, and the new object is set up to read from it.

Type, variable name, then an initialisation that creates an object on the spot. new tells the JVM to allocate the right amount of heap memory for a Scanner and run a special method called a constructor — here the one that takes System.in. A constructor is where the object’s data members are normally initialised and anything else it needs is prepared. It runs once per object, and always first.

public class <ClassName> {

    <access modifier> <ClassName>(<parameter list>) {
        <code>
    }

}

An access modifier and a parameter list, like any method — but no return type, not even void.
Its name is the class’s name, so it is one of the few method names that starts with a capital letter.
A class can have several constructors, following the normal overloading rules.
If you write no constructor, Java supplies a default constructor that takes no parameters and does nothing beyond creating the object. That is why new Empty() worked in section 2.2.

The catch in that last rule: no constructor. Write one of your own and the free one is gone:

The error line. new Point() asks for a constructor with no parameters, but Point declares only Point(int, int), so the program does not compile (this console: The constructor Point() is undefined). Either pass two ints, as in new Point(0, 0), or declare a Point() yourself.
Declares two int data members in one line. Each Point object gets its own x and y, and only code inside Point can reach them.
Named after the class, with no return type — not even void. Because the class now declares a constructor, Java no longer supplies the free default Point(), and that is what breaks line 3.
Inside the constructor, a plain x means the parameter, which hides the field of the same name. this.x is the field of the object being built, so this line copies the argument into it (section 4.3).

Ed’s javac words it as constructor Point in class Point cannot be applied to given types. The fix is to declare a Point() yourself, if a point with no coordinates makes sense — which is where the next section’s trick comes in.

4.3`this`

An object can always get a reference to itself with the keyword this. It has two handy uses:

Telling a field from a parameter with the same name: this.x = x; sets the object’s x to the value of the parameter x. Common practice in constructors.
Calling another constructor: this(0, 0, 0); runs a different constructor of the same class. It must be the first line of the calling constructor. This lets a short constructor fill in defaults without repeating code.

static: a single copy, stored with the class rather than in each object. final: it can never be changed. The value is a poor π — Math.PI is the one to use.
Lines 5–8 are not static, so every Circle gets its own four variables on the heap. Until a constructor sets them, the numbers are 0.0 and colour is null.
The class’s name and no return type make it a constructor. The comment calls it the default constructor, but strictly that name belongs to the one Java supplies when you write none (4.2); this one is written by hand.
this(…) runs the constructor of this class whose parameters fit the arguments — three numbers, so line 16 — with the int zeros widened to double. It must be the first statement in the constructor.
Passes its own three parameters on, adding a default colour, to the four-parameter constructor. Writing the default here means no caller has to supply it.
The parameter x hides the field x, so this.x is needed to reach the object’s field. Written as x = x;, the parameter would be assigned to itself and the field would stay 0.0.
The instance method passes this object’s radius to the static area(double). The two areas are overloads, told apart by their parameter lists (Week 4, 3.3).
A getter: a public method that lets other code read a private field. No parameter is called x, so return x; would mean exactly the same; the this. only makes it explicit.
Picks the constructor on line 16, which passes everything on to line 21 with "Colourless". The int arguments are widened to double, so the object holds 6.0, 7.0 and 3.0.
Runs area() on the object c refers to, using its radius of 3.0. The result, 3.141529 × 9, prints as 28.273760999999997 because a double cannot hold most decimals exactly.
Line 11 calls line 16 with zeros, which calls line 21 with "Colourless". Only line 21 sets fields, so d ends up at (0.0, 0.0) with radius 0.0 — one place to get it right.

Follow new Circle(): it calls the three-parameter constructor with zeros, which calls the four-parameter one with "Colourless". Only one constructor actually sets fields, so there is one place to get it right. (This PI, 3.141529, is the Ed lesson’s own “approximation” — it even has two digits swapped compared with section 3.2’s. One more reason to use Math.PI.)

4.4Two variables, one object — again

Because an object variable is a reference, everything Week 4 showed for arrays holds for objects you design yourself. Copy the variable and you have two names for one account; pass it to a method and the method can change the account through it:

A class is a type (2.4), so it can be a parameter’s type. The call copies the reference into account, so it refers to the caller’s object; the account itself is never copied.
The inner call runs first: getBalance() returns the balance, and 10% of it goes to deposit. That changes the object account refers to — the same object as main’s a.
new makes the object on the heap and the constructor on line 25 sets its two fields; the int 100 is widened to 100.0. a receives a reference to it.
No new, so no new account: b now refers to the very object a refers to — Week 4’s “backup” array again.
A second new makes a separate object with the same starting data. Nothing done through a or b can reach it, so it keeps its 100.0.
Deposits into the one object that a and b share, so it holds 150.0. Line 13’s interest adds 15.0 more, and line 14 shows 165.0 for both names.
== on object variables compares the references, not the contents. a and b refer to the same object, so it is true.
Both accounts began as Linh with 100.0, but they are two objects in two places on the heap, so == gives false. Comparing contents would need a method written for the job.

== on objects compares references

a == c is false although the two accounts started identical: they are two different objects, and == asks “are these the same object?”. That is also why two Strings are compared with .equals — a String is an object, and two Strings with the same letters need not be the same object. Enums, in section 7, are the pleasant exception.

4.5The pizza shop, with classes

The Ed lesson finishes by rebuilding the pizza shop with classes, over four video parts and forkable workspaces. Here is one way to do it: a Pizza that knows its name and price (in cents — section 1.4), and an Order that holds pizzas and can total itself. Enter three selections, then 0 to finish:

One menu for the whole class (static), assigned once (final). Its element type is the class Pizza, so each element is a reference to a Pizza object.
Each new runs Pizza’s constructor (line 36). A static variable is initialised along with its class, so the three pizzas exist before main starts. Prices are whole cents (section 1.4).
MENU[i] is a reference to one Pizza; the dot follows it and calls that object’s describe(), which returns its name and price as one String.
Runs Order’s constructor (line 60) with capacity 10, which sets up an empty array for the pizzas and a count of 0.
Choices 1–3 become indices 0–2. add stores the reference to the menu’s Pizza, so choosing 2 twice puts two references to the same object in the order.
order.total() returns the sum in cents, and Pizza.dollars formats it. dollars is static, so it is called on the class name, with no Pizza object involved.
The parameter has the field’s name, so this.name means the new object’s field and plain name the argument passed to the constructor.
Inside the class the static dollars needs no class name. An instance method can call a static one freely; the reverse needs an object (3.3).
% gives the remainder after dividing by 100 — the cents — and adding it to "" turns the number into a String. Line 52’s cents / 100 is integer division, giving the whole dollars.
Pads a single-digit cents value with a leading zero, so 1205 shows as $12.05 rather than the misleading $12.5.
Makes an array of 10 Pizza references, every one null. No Pizza object is created here; add fills the slots later.
The loop stops at count, not pizzas.length: the unused slots are still null, and calling getPrice() on null would throw a NullPointerException.

Read main and notice who does what: the shop never adds prices up itself — it asks the order — and never formats money itself — it asks the static helper on Pizza. Two orders of the same pizza hold two references to one Pizza object from the menu, which is fine: nobody changes it.

05Classes and objects in Python

5.1Roughly Java’s model

Python’s object model is roughly similar to Java’s: a class is a template, objects are instances of it, and the class itself is still a thing in the code, so data and functions can live on the object or on the class.

And since every Python variable is already a reference (Week 4, section 7.4), two variables can hold references to the same object and change the same object — exactly like the Java accounts in section 4.4.

5.2Classes and objects

A class is defined much as you would guess: class, a name, a colon, and indentation.

class, a name and a colon; every indented line below belongs to the class. There are no braces and no public, and Python does not tie the class to a file name as Java does.
An assignment directly in the class body creates a variable on the class itself — one copy, like a Java static field (3.1), not one per object.
Written like any function, but indented inside the class, so it belongs to it. With no parameters it can only be called through the class, as on line 11 — a static method, in 5.3’s terms.
Back at the left margin, so this line is outside the class — and it is the first to print, because running the class statement only made the class, without calling func.
The dot reaches an attribute of the class directly, with no object made — like Java’s Silly.value in 3.1.
Calls func with no arguments, matching its empty parameter list. Calling it through an object instead fails — that is the “Forgot self” example below.

Objects are created by calling the class like a function, with whatever arguments it needs — no new:

An instance method’s first parameter receives the object the method was called on. It plays the part of Java’s this, but is written out in the parameter list; the name self is only a convention, though a universal one.
Calling the class like a function creates a new Foo object and returns a reference to it, which obj then holds — no new. No arguments are needed, because Foo has no __init__ asking for any (5.4).
The brackets are empty, yet bar has one parameter: Python passes obj in as self, so this does the same as Foo.bar(obj). Without an object, Foo.bar() fails: TypeError: Foo.bar() missing 1 required positional argument: 'self'.

5.3Attributes, and three kinds of method

Python’s general word for a class’s data and functions is attributes, reached with the dot, just as in Java. Once functions live on a class or an object they are called methods, and there are three kinds:

Kind	Declared	First parameter	Called as	Closest Java
static method	a plain function in the class, optionally marked `@staticmethod`	none	Foo.baz(x)	a static method
class method	`@classmethod`	`cls` — the class, supplied automatically	Foo.bar()	a static method that uses static data
instance method	no marker	`self` — the object, supplied automatically	obj.bar()	an ordinary method; `self` is like `this`

One copy, on the class, which line 14 reads through cls. The double quotes delimit the string; the single quotes are part of its text, so they show in the output.
No marker and no parameters, so it works as a static method when called through the class, as on line 20. Through an object, obj.bar() would fail, because Python would pass the object in with nowhere to put it.
A line starting with @ modifies the def below it. @staticmethod tells Python never to pass in the object or the class, so baz can safely be called either way: obj.baz(5) works too.
thing has no type, so the caller may pass anything; str turns it into text before + joins it. Without it, Foo.baz(42) would raise a TypeError.
With @classmethod, Python passes the class itself as the first argument, named cls by convention — whether the call goes through the class or through an object.
Here cls is Foo, so this reads the attribute from line 3. Reaching the class’s data through cls is what a class method is for — the table’s “static method that uses static data”.
No marker, and a first parameter that receives the object. It is the only one of the three kinds that needs an object: through the class, Foo.hello() fails with TypeError: Foo.hello() missing 1 required positional argument: 'self'.
No argument is written, yet show has one parameter: Python fills cls with Foo, the class before the dot.
In the same way, Python fills self with obj, the object before the dot. Line 25 had to create that object first, by calling the class.

Why must an instance method take self? Because calling a method through an object passes that object in as the first argument. A function with no parameter has nowhere to put it:

An empty parameter list: func can accept no arguments at all. Called through the class, Simple_Class.func(), it works as in 5.2; to call it through an object it needs def func(self):.
Creating the object works; nothing goes wrong until a method is called through it. Python only finds the problem at run time, on line 7.
Calling through an object passes obj in as the first argument, so func receives one argument though the brackets are empty. Python stops with TypeError: Simple_Class.func() takes 0 positional arguments but 1 was given — the 1 is obj.

The word “static” is being used slightly differently from Java: the intent is the same (no object needed), the details are not. What Java calls a static method is often closer to Python’s class method.

5.4`init` and instance data

Unlike Java, Python instance data is generally not declared in the class. It is created in the __init__ method — Python’s equivalent of a constructor, and an instance method — by assigning through self, and read back through self too. Every class has an __init__, even if you do not write one.

Python calls __init__ automatically on each new object, straight after creating it, with the object as self. You do not call it yourself: Foo() on line 9 does.
Assigning through self creates an attribute on this object — there is no declaration anywhere else. Each Foo object gets its own secret, unlike a class attribute.
self always comes first; the caller’s arguments fill the parameters after it, so line 10’s single argument goes to num.
The object’s data is reached only through self: Java’s this. is optional, Python’s self. is not. A bare secret here gives NameError: name 'secret' is not defined.
The new object is passed to __init__ as self, which gives it its secret. No argument is written because __init__ has no parameter besides self.
obj goes in as self and 2 as num; the method returns 2 * 3, and print shows that value.

With parameters, __init__ does exactly the job of section 2.3’s Java constructor. The same bank account, in Python:

The job of Java’s BankAccount(String customerName, double startingBalance), with self added at the front and no types. Callers supply only the two after self.
The same move as Java’s this.customerName = customerName;: the left side is the object’s attribute, the right side the parameter. Here self. cannot be left out — customer_name = customer_name would only assign the parameter to itself.
Java declared private double balance; at the top of the class; in Python this assignment is what creates the attribute, and nothing makes it private.
Line 8 lets only positive amounts through, as in Java’s deposit. self is whichever account the method was called on, so only that object’s balance changes.
Calling the class makes the object and runs __init__: the new object goes in as self, then "Linh" and 100.0 fill customer_name and starting_balance.
account goes in as self and 50 as amount. An int added to the float 100.0 gives a float, which is why the balance shows as 150.0.
Python attributes are public, so code outside the class reads balance directly, where Java’s private field needed getBalance(). Writing it is just as open, as the note below says.

Nothing stops account.balance = 1000000 here: in Python, attributes are public unless you say otherwise. Section 6.3 is what “otherwise” looks like.

06Dunder methods and open doors

6.1“Dunder” methods

Python has methods with special names, surrounded by double underscores — hence “dunder”, also called magic or special methods. They connect a class to the built-in functions and operators of the language. __init__ is one: it hooks into object creation.

Another is __str__, the method str() calls — and print too — much like Java’s toString(). Each dunder has its own rules: __init__ may take extra parameters and returns nothing; __str__ takes only self and must return a string.

Money(1250) makes a new object and calls __init__ on it, with self as the new object and cents as 1250. Keeping whole cents in an int avoids floating-point rounding.
Called by str(), and so by print, whenever a Money must become text. It takes no parameter but self and must return a str.
// is floor division, so 1250 // 100 is 12. str() turns the int into a string so + can join it to the others.
% gives the cents left over (5 for 305), and the string method zfill(2) pads with leading zeros to two characters, giving 05 rather than 5.
For a + b Python calls a.__add__(b): self is the left operand, other the right. It returns a brand-new Money, leaving both operands unchanged.
print converts its argument with str(), which calls Money.__str__. Without a __str__ you would see something like <__main__.Money object at 0x…>.
Gives a real string, so + here is string concatenation. Without str(), drink + " extra" would call __add__ with a string, which has no cents.
Becomes pizza.__add__(drink), which returns Money(1555); print then shows it through __str__.

Dunders are the standard way to give your own type built-in behaviour: __add__ for +, __lt__ for <, and many more. (Java has no equivalent for operators: + on your own class is simply a compile error.)

6.2Horrible things you can do in Python

At a simple level, a Python class’s attributes behave like a dict, and access is public by default — so other code can replace them, if it knows the names. Offered without further comment, from the Ed lesson:

Assigned in the class body, so it belongs to the class m itself, not to any object, and is reached as m.val or cls.val.
No self and no cls, so in section 5.3’s terms this is a static method: m.f() works, but calling it through an object would fail, since there is no parameter for the object.
The decorator makes Python pass the class itself as the first argument, cls, so m.f1() returns m.val — 9 — without needing an object.
An annotation saying the method returns an int. It documents intent only: Python does not check it.
Methods are just attributes of the class, so this assignment rebinds the name f to the function three. The original f is gone, and m.f() now runs three.
The class method is replaced by a plain function, so the @classmethod behaviour goes too: m.f1() now calls three with no arguments.
Assigning to a name the class never had simply creates it, at run time. In Java, using an undeclared field like this is a compile error.

A method replaced from outside the class, and a brand-new attribute bolted on at run time. The Java compiler would reject every one of these lines. Python lets you — which is precisely why you should not.

6.3How to stop (some of) that

Python gives you a way to discourage this. Unless you say otherwise an attribute is public. Start its name with two underscores and code outside the class can no longer reach it by that name:

A class attribute whose name starts with two underscores (and does not end with two). Inside the class body Python stores it under another name — the last example in this section shows which.
Outside the class nothing is renamed, so Python looks for an attribute literally called __priv_data, finds none, and stops with an AttributeError.

It works for methods too — but not for dunder methods, even though they look similar, because a dunder name also ends in two underscores:

The name ends in two underscores as well, so Python does not rename it. It also breaks the __str__ rule by having no self: print(Foo()) would fail with a TypeError.
Two leading underscores but not two trailing ones, so inside the class Python stores this method as _Foo__hidden.
Looks up __str__ on the class and calls it with no arguments, which suits a method with no parameters.
The lookup itself fails, before any call: the class has no attribute called __hidden, so Python raises an AttributeError.

Now look back at the error from the first example: Python itself suggests _Foo__priv_data. The two underscores do not make the attribute private in Java’s sense; inside the class, Python quietly renames it (“name mangling”), and the new name works from anywhere:

Inside class Foo, Python rewrites __priv_data as _Foo__priv_data: one underscore, the class name, then the original name.
The mangled name is an ordinary attribute name, so any code can use it. The renaming exists to avoid clashes with names in subclasses, not to stop access.

“Private” instance variables that cannot be accessed except from inside an object don’t exist in Python.

The Python Tutorial, §9.6 Private Variables

So the double underscore is a strong “keep out” sign, not a lock — which matches section 1.3’s point that encapsulation is about safety, not security. A single leading underscore (_spam) is the other convention, which the tutorial describes as marking a non-public part of the code; the Ed lesson calls this “protected” and leaves it for later. Neither stops you adding brand-new attributes at run time.

07Enums

7.1Enumerated types

An enumerated type is a data type with a fixed, finite set of named values. There are many ways to implement one, but the goal is always the same: data of that type can only ever be one of the known values. They appear in most languages descended from Algol — Pascal, C, C++, C#, Java — and in Swift, Fortran, Lisp, TypeScript and every functional language with algebraic types.

The classic example: a standard deck has exactly four suits, so any question about a card’s suit must be answered with one of those four, and nothing else.

7.2Enums in Java

enum <Name> { [<VALUE_NAME> [, <VALUE_NAME>]*]; }

The keyword enum, a name (capitalised like a class), then a comma-separated — possibly empty — list of value names ending in a semicolon. By convention the values are in capitals, like constants. An enum can be declared on its own or inside a class. A value is reached as Suit.HEARTS, like a field, and every enum has a values() method that works with the for-each loop:

The keyword enum declares a new type, Suit, whose values are exactly the ones listed. Declared inside Cards, it can be used anywhere in the class, like any other type.
Capitals by convention, as for constants, with a semicolon after the list. The order written here is the order values() hands them back in.
Declared like an int or String variable, but it can hold only a Suit. The value is reached through the type’s name, like a field; trumps = 3; would not compile.
Joining a value to a string calls its toString(), which by default gives the value’s name exactly as declared, SPADES.
Every enum has a values() method that returns a Suit[] holding all its values in declaration order — just what the for-each loop needs.
There is only ever one SPADES object, so comparing references with == correctly answers “is this the same suit?” (section 7.3).
If the comparison is true, the bracket’s value is " <- trumps"; otherwise it is the empty string, so only the trumps line gets the arrow.
Because values() returns an array, .length — no brackets, it is not a method — gives the number of values, 4.

Enums arrived in Java 5. ? : is the conditional operator from the Weeks 2+3 operator tables — a tiny if/else that produces a value.

Did you know?

Before Java 5, the standard way to write an enumerated type was a row of int constants: public static final int SEASON_WINTER = 0; and so on. The Java 5 release notes list what was wrong with it, starting with “Not typesafe” — any int could be passed where a season was expected, and two seasons could be added together. Enums fixed that by making each set of values a type of its own. Source: Oracle — Enums (J2SE 5.0 guide).

7.3`==` is safe on enums

Java enums are implemented as a special kind of class: think of a class with a fixed number of pre-declared objects — the values. You cannot create more (or fewer) of them, so you never need a constructor call, and there is exactly one object for each value. The Java Language Specification: “An enum class has no instances other than those defined by its enum constants.”

So, unlike the accounts in section 4.4, comparing with == works as you would naively expect — for enums, .equals gives the same answer as comparing references, because there are never two copies of the same value.

7.4Switching on an enum

You can switch on an enum value. Inside the switch, the cases are written without the enum’s name:

The number read becomes an index into the array of values, in declaration order, so 2 gives DIAMONDS. A number outside 0–3 throws an ArrayIndexOutOfBoundsException.
Allowed since Java 5. This classic switch statement jumps to the case matching the value of s, and it does not check that every suit has a case: leave one out and it still compiles.
The switch already knows s is a Suit, so the case label is the bare name HEARTS, without the enum’s name in front.
case HEARTS: has no statements of its own, so it runs straight on into this label: hearts and diamonds share the same println.
Jumps out of the switch. Without it, a red suit would fall through into the black cases and print both lines.

This is the classic switch statement from Weeks 2+3, stacked cases and all. It does not check that you covered every value. Put a return in every case of a method and the compiler still wants one more, because as far as it is concerned the switch might match nothing:

The return type String means every way through the method must end in a return of a String. This page’s console flags the error on this line: the method must return a result of type String.
A classic switch statement with no default is treated as possibly matching nothing — the compiler does not count the cases against the four values of Suit.
A return leaves the whole method at once, so these cases need no break.
As far as the compiler knows, the method could reach this closing brace without returning. javac reports missing return statement at this brace. Adding default: return "unknown"; fixes it.
This call would match HEARTS perfectly well, but a compile error anywhere stops the whole program, so nothing runs.

Week 4’s missing return statement again. Add default: return "unknown"; to satisfy it. The newer switch expressions in section 8 are checked for exhaustiveness — one of the Ed lesson’s selling points for them.

7.5Enums are classes, so they can have methods

Because an enum is a class, you can add methods to it — and each value is an object, so this inside the method is “whichever value I am”. Here each suit knows its own symbol and colour:

Now the braces hold more than a list of values: after the values come ordinary method declarations, just as in a class.
The values must come first. With methods following, the semicolon after them is required: it separates the values from the rest of the body.
No static, so the method belongs to each value: it is called on one, as s.symbol(), and works with that value.
Inside the method, this is the value it was called on, so switching on this picks the symbol for whichever suit is asking.
The last suit is caught by default rather than case CLUBS, so every path ends in a return and there is no missing return statement as in 7.4.
true when this value is one of the two red suits. Inside the enum the values need no Suit. in front, and == is safe because each exists exactly once.
Dot notation, as with any object: symbol() runs with this set to s and returns that suit’s character.
The boolean from isRed() picks the word. The brackets matter: without them the whole joined string to the left would become the condition, and a String is not a boolean, so it would not compile.

An enum can also hold fields and constructors of its own, which the Ed lesson mentions but does not go into. And one striking application: make a class an enum with a single value, and the compiler itself guarantees there is exactly one instance — the Singleton pattern, with no checking code at all.

7.6The deck of cards

The Ed lesson’s full example builds a short (Euchre) deck: two enums, a record for a card, and switch expressions to print them. Records (Week 4) and switch expressions need Java 16 and 14, so it will not run in this page’s Java 8 console — here is its second version, with the printing moved into the enums, and its real output. Run it on Ed.

An annotation: this toString() replaces the one every object inherits. The compiler checks the claim, so a misspelt tostring() would be an error rather than a silent new method.
A switch expression (Java 14, section 8): the whole switch works out to one value, which is returned. That is why it ends with }; on line 18.
After the -> comes the value the switch produces for HEARTS. Arrow cases never fall through, so there is no break.
A switch expression must cover every possible value. These four cases cover all of Suit, so the compiler accepts it without a default — unlike the switch statement in 7.4. Leave a suit out and it will not compile.
Five values times four suits makes a 20-card deck. This order is the order values() returns, so each suit prints as A, 10, J, Q, K.
A card is a suit and a value, held together in a Week 4 record. Because the components are enum types, a Card can only ever hold a real suit and a real value.
Calls the two enums’ toString() methods, value first, so a card prints as A♥. Without this override the record’s own form, Card[suit=♥, value=A], would be used.
Seeded from the clock (milliseconds since 1970), so each run gets a different sequence of random numbers, and so a different shuffle.
4 suits × 5 values = 20 slots. Because it is worked out from the enums, adding a value to either would resize the deck automatically.
The nested for-each loops visit every suit-and-value pair. i++ uses i as the index and then adds 1, so the cards fill slots 0 to 19 in order.
Returns a random int from 0 up to, but not including, 20 — always a valid index. Each card in turn is swapped with the one at this random position.
Printing an object calls its toString(): here Deck’s, whose Arrays.toString builds the square-bracketed list from each card’s toString(), which in turn uses the enums’.

Output (the shuffled line is different every run)

Check that all the cards are there:
[A♥, 10♥, J♥, Q♥, K♥, A♤, 10♤, J♤, Q♤, K♤, A♦, 10♦, J♦, Q♦, K♦, A♧, 10♧, J♧, Q♧, K♧]
Now we can shuffle them:
[Q♧, J♦, A♤, Q♦, 10♧, K♥, A♥, 10♥, A♦, J♥, K♤, K♧, A♧, Q♥, J♧, K♦, 10♦, 10♤, Q♤, J♤]

@Override marks a method that replaces one the class would otherwise inherit — here, the toString() every object has, which is what + and println call. That is inheritance showing through, a lesson early. The same deck in Java 8 terms — a small Card class instead of the record, classic switches instead of switch expressions — runs right here:

A switch statement, which Java 8 understands: each case returns its symbol, so no break is needed.
A switch statement is not checked for completeness, so with four cases the compiler would still report a missing return (7.4). Catching the last suit with default guarantees every path returns.
A small class nested inside Deck. static means a Card does not belong to any particular Deck object — a nested record is like that automatically.
Each record component becomes a field written out by hand: private so only this code can see it, final so it is set once and never changed.
The record wrote this for us. It is named after the class, has no return type, and runs when new Card(s, v) is called.
The parameter has the same name as the field: this.suit is the field of the card being built, suit the value passed in.
A plain class has no readable printed form of its own: without this method a card would print as something like Deck$Card@1b6d3586. The enums’ own toString() methods supply A and ♥.
The seed is the current time in milliseconds, so every run produces a different shuffle — run it twice and compare.
Exactly as in the record version: the nested loops make each suit-and-value pair once, and i++ moves on to the next slot after each card.
Holds card i while its slot is overwritten with the random card; line 69 then puts it in the random slot. Without temp, one of the two cards would be lost.

Run it twice: the shuffle changes, because the Random is seeded from the clock. Compare the two versions line by line — everything the record and the arrows did is here written out in full.

7.7Python enums (sort of)

Python has enums too, somewhere between Java’s approach and C’s. You import Enum from the enum module and create your enum as a class that extends it — inheritance again, a little early — listing names with values. The example the Ed lesson takes from the Python documentation, with two lines added:

Brings the class Enum in from the standard library’s enum module; without it, Enum on line 3 would be an undefined name.
The base class in brackets means Colour extends Enum, which turns the names in the class body into enum members rather than ordinary class variables.
Each NAME = value line makes one member. Unlike Java, you choose the value and it can be anything; 1 to n is just the usual habit.
Reached through the class, like an attribute. c now refers to the member object Colour.RED, not to the integer 1.
print uses the member’s string form, which by default is the class name and member name, Colour.RED, not the value. The next example replaces it.
Every member carries both: .name is the string 'RED', and .value is whatever it was given in the class, here the integer 1.
There is only one Colour.RED object, so this is True; c is Colour.RED would be True as well.
A member is not equal to its value, so this is False. Compare with c.value instead, or go from the number to the member with Colour(1).

As they are classes, you can add methods — here the dunder __str__ from section 6.1, which print then uses:

Names given values become members, but a def in the body is an ordinary method. __str__ is the dunder that print and str() use for the text form, so this replaces the default Colour.RED.
The member the method was called on — Python’s version of Java’s this in section 7.5.
self.name is the member’s name, such as 'RED'; the string method lower() returns a new lower-case copy, 'red', leaving the name itself unchanged.
print asks the member for its string form, which now runs our __str__ with self set to Colour.RED.

The differences from Java are in the values. They can be anything — you would normally see the integers 1 to n, but RED = "red", GREEN = 2, BLUE = 3.0 is allowed. And nothing stops two names sharing a value, which quietly changes what the names mean:

The first name with the value 1 creates a member, RED.
The value 1 is taken, so no new member is made: GREEN becomes a second name for RED. Python raises no error unless the class is marked with the @unique decorator from enum.
Gives back the member the alias stands for, RED, so c refers to Colour.RED.
The printed form uses the member’s own name, so it shows Colour.RED even though we asked for GREEN; c.name is 'RED' too.
is is True only when both sides are the same object — and they are, because GREEN and RED name one member.
len counts members, and aliases do not count, so the “three-colour” enum has length 1. A for loop over Colour would likewise visit only RED.

A second name with an existing value becomes an alias for the first member, so this “three-colour” enum has one member, RED, with two extra names. The Ed lesson’s conclusion stands: Python enums work well when used as intended, without the guarantees of Java’s. (The members are objects of the enum class, though: isinstance(Colour.RED, Colour) is True, as the Python enum HOWTO shows.)

7.8And in C, just numbers

For comparison: an enum in C is a set of names for the numbers 0 to (number of values − 1), assigned automatically. That keeps the key property — a fixed set of distinct values — but not Java’s type safety: underneath, it is just an int.

C numbers the names automatically, in order: HEARTS is 0, SPADES 1, DIAMONDS 2, CLUBS 3. They are plain int constants, used with no Suit in front.
In C the type is called enum Suit, both words, every time it is used. Declared outside any function, s is a global variable, which C starts at 0.
SPADES is the number 1. C would accept s = 42; just as happily — nothing ties s to the four suits, which is the type safety Java’s enums add.
%d prints an int in decimal, and s is one underneath, so out comes its number rather than a name. C has no built-in way to turn an enum value back into its name.

Output

08Advanced `switch`

Weeks 2+3 taught the switch statement: equality only, fall-through, and break. Java has since added three things: switch expressions, pattern matching, and when clauses. All three need a newer Java than this page’s console — section 8.2 shows exactly what happens if you try — so most examples here are static, with their real output from a current JDK. Run them on Ed, which uses Java 23.

8.1Stretching the old switch

A plain switch only tests equality, but careful choice of the expression you switch on can stretch it. This runs anywhere, including here:

The Scanner method nextInt reads the next whole number typed and returns it as an int, ready to switch on.
Works out the expression in brackets once, then jumps to the case whose value is equal to it. That single calculation is the only work done before choosing.
% gives the remainder after dividing by 2, which is 0 for every even number. Switching on it turns “is n even?” into an equality test, the only test a plain switch can do.
Matches only when n % 2 equals 0 exactly. A plain case label must be a constant, so a condition such as case n > 0: is not allowed.
Jumps out of the switch. Without it an even number would fall through into the default code and print both lines (Weeks 2+3, section 3).
Runs when no case matched. It is better than case 1: here: for a negative odd number, n % 2 is −1 in Java, and default catches that too.

But the only computation happens once, in the switch’s own expression. The newer features let each case do some of the work.

8.2Why the rest will not run on this page

Here is a switch expression — section 8.3 explains it — in the page’s console. Run it and read the error. It is not a mistake in the program; it is the compiler telling you which version of Java you need:

Joining a switch to a string with + works only because a switch expression has a value, here "even" or "odd". Section 8.3 explains how.
ECJ, this console’s compiler, is set to Java 8 and underlines the whole switch: Switch Expressions are supported from Java 14 onwards only. Nothing is wrong with the program itself.
The arrow form case … -> belongs to the same Java 14 feature, so ECJ flags it separately: Arrow in case statement supported from Java 14 onwards only.
The same error for the second arrow — three errors in all, each naming the Java version needed rather than a mistake to fix.
A compile error means nothing runs, not even the prompt on line 6. On Java 14 or later, such as Ed’s Java 23, the input 7 makes this line print The number is odd.

8.3Switch expressions

A switch expression is like a switch statement, except that each case produces a value. The syntax changes to case … -> <value>;: an arrow where you would expect a colon, and no break. The switch hands back the value after the arrow and is finished — no fall-through, much as a return ends a method. And because it produces a value, it can go anywhere an expression can (Weeks 2+3, section 1.2):

Here the switch is an operand of +: it produces a String, which is joined to "The number is ". A switch statement could never stand in this spot.
If n % 2 is 0, the whole switch has the value "even" and is finished: no break, and no fall-through into the next case.
A switch expression must be exhaustive, and an int has far more values than 0, so default is required. Replace it with case 1 and javac reports that the switch expression does not cover all possible input values.

Output, with input 7

Enter a number: The number is odd

Switch expressions must also be exhaustive: every possible value has to be covered. On an enum that means every constant — which is how the Ed deck’s toString in section 7.6 gets away with no default, and why deleting a case there is a compile error rather than a silent bug. Compare section 7.4’s old-style switch, which needed a default anyway.

Did you know?

Switch expressions are older than they look. They were previewed in Java 12 and 13 and became a standard feature in Java 14, in 2020 (JEP 361). The Ed lesson presents them alongside newer features that they combine with. Source: JEP 361 — Switch Expressions.

8.4Pattern matching and `when`

Pattern matching lets a case examine the type and structure of the value being switched on, and give it a name. A when clause then narrows a case to a sub-case with any boolean condition:

nextLine returns a String, which an Object variable can hold. Declared as Object, n could in principle be anything, so the switch has to find out what it is.
The old switch accepted only a few types, such as int, char, String and enums. With pattern matching (Java 21) it can switch on any object.
Matches if n is a String and, if so, names it s, with type String, for this case only — so String methods can be called on it.
Narrows the case: it matches only if the boolean condition after when is also true. length() returns the number of characters, 0 for an empty line.
Colon cases still fall through, so the breaks stay. Leaving this one out is a compile error: javac will not let execution fall through into a case that declares a pattern variable like s.
Every String the first case did not take lands here. Put this case first and javac refuses the program, since the guarded case could never match: this case label is dominated by a preceding case label.
A switch that uses patterns must cover every possible value, and n could be any Object. Remove the default and javac says the switch statement does not cover all possible input values.

Two runs: an empty line, then Linh

Enter a name: You didn't enter a name!

Enter a name: The name you entered was Linh

case String s matches if n is a String, and names it s for that case; when s.length() == 0 restricts the first case to the empty ones. Pattern matching works on objects — it is why n is declared as Object here (the most general type; more when inheritance arrives). Matching on primitive types is still a preview feature.

You have seen this idea in Python

Python’s match (Weeks 2+3, section 4.3) has the same thing, called a guard: if after the pattern. And unlike the Java above, it runs in this page’s console:

Shows the prompt, waits for a line and returns what was typed as a str, without the newline. Pressing Enter alone gives the empty string ''.
Tries each case pattern against name, top to bottom, and runs only the first that matches. There is no fall-through and no break.
A bare name matches any value and binds it to s — like Java’s case String s, but with no type check.
Python’s version of when: the case matches only if this condition is also true. len gives the number of characters, 0 for an empty line.
With no guard this pattern matches anything, so it must be the last case — Python rejects any case after it with a SyntaxError. It does the job of Java’s default.

8.5Record patterns, `_`, and a switch with no default

A tantalising hint of how far this goes, using a record from Week 4:

A name and a mark, with a constructor and component methods written for you. Because its components are known, a pattern can take it apart again.
The parameter is an Object, so grade accepts a Student or anything else; the switch works out which it got. Line 25 passes it luke.
The switch produces a String, and return hands it straight back. The ; after its closing brace on line 16 ends the return statement.
Matches if o is a Student and deconstructs it: the mark component goes straight into a new variable mark, with no need to write mark().
Cases are tried in order, so a mark over 100 is caught here, before mark >= 85 on the next line could claim it.
The name component must be listed to match a Student’s shape, but grading never uses it, so it gets the unnamed variable _ (Java 22) instead of a name.
Reaching this case means the mark is neither over 100 nor 85 or more, so >= 75 here really means 75 to 84 — just like an else if ladder.
No when, so it matches any Student still left: by now, any mark below 50, negative ones included.
Matches any object at all, so together the cases cover every possible value of o. The switch is exhaustive, as a switch expression must be, with no default.

Three runs: 92, 105, 40

What mark should Luke get? Luke got a HD.
What mark should Luke get? Luke got a caution for cheating.
What mark should Luke get? Luke got a Z.

Deconstruction: Student(String _, int mark) matches a Student and pulls its components out, straight into variables.
_ means “I don’t care about this one” — the name is never used, so it is never named.
No default: case Object _ matches anything left, so the compiler can see the switch is exhaustive.
The cases are tried in order, so 105 hits the first one before it could reach >= 85 — the same ordering rule as an else if ladder in Weeks 2+3.

Which Java, exactly?

The Ed lesson says these became standard “as of Java 23”, the version Ed runs. To be precise: pattern matching for switch and record patterns became standard in Java 21 (JEP 441, JEP 440), and the _ unnamed variable in Java 22 (JEP 456). Everything here works on Ed’s Java 23.

09Coding exercises

Eight exercises, marked automatically against test cases — the same idea as the Ed labs, but nothing here is recorded or submitted. Write your answer, press Run tests, and read what comes back. A worked solution sits under each one, but try it first.

Output must match exactly

A capital letter or a missing full stop fails the test, exactly as it would on Ed. Trailing spaces and the final newline are the only things forgiven.

The tests check output, not design

A program that prints the right thing without the class the brief asks for will pass — and miss the point. Each brief names the class, its private data and its methods; write them, and use them from main. The Java exercises put two classes in one file, like section 1.3: only the one with main is public.

10Team activity

Three or four people, fifteen minutes, then two minutes to report back. These run in the lecture and in the lab — class activities like these count towards the participation side of your mark.

Activity 1 · 10 min · no computers

Nouns and verbs: design a library

A small library lends books to members. A member can borrow at most three books; a book is either on the shelf or on loan to exactly one member.

Underline the nouns. Which ones deserve to be classes, and which are just data inside a class?
For each class, list its private data and its public methods. Which class should enforce “at most three books”?
Is there a fixed, finite set of values anywhere in the description? Should it be an enum?

Report back: the rule your group moved from one class to another, and why.

Activity 2 · 10 min · one laptop per group

Break the encapsulation

Take section 2.3’s BankAccount and make balance public.

Write the shortest main you can that leaves an account in a state the methods would never allow.
Now make it private again. Could the same bug still happen? From where?
Do the same with section 5.4’s Python class, then with a double-underscore name. What did the underscores actually stop?

Report back: the worst realistic bug that private prevents.

Activity 3 · 10 min · discussion

int constants versus an enum

Someone writes static final int HEARTS = 0, SPADES = 1, DIAMONDS = 2, CLUBS = 3; instead of an enum.

Write a line that compiles with the int version but is nonsense. Would it compile with the enum?
What does System.out.println print for a suit in each version?
Section 7.7’s Python enum with duplicate values: which of your problems does it share?

Report back: the one-sentence case for enums you would make to that someone.

Why we do this out loud

Designing classes is mostly an argument about where things belong. Having that argument with other people, early and often, is the fastest way to get good at it.

12Further reading

None of this is assessed. It is here for the moment a section leaves you curious, and for the claims above that you should check rather than take our word for.

The official word

Tutorial · sections 2–4

Classes and objects

Oracle's walkthrough of declaring classes, fields, constructors, this, and class versus instance members — the reference version of sections 2 to 4.

docs.oracle.com Tutorial · section 7

Enum types

Enums with fields, constructors and methods — the part section 7.5 mentions but does not show, with a solar-system example.

docs.oracle.com Tutorial · sections 5, 6

Python classes

Chapter 9 of the Python tutorial: class and instance variables, methods, and §9.6 on private variables and name mangling.

docs.python.org HOWTO · section 7.7

Enum HOWTO

The Python guide to enums: names and values, aliases for duplicate values, and why members are instances of their class.

docs.python.org

Behind the claims on this page

Paper · section 1.1

A History of C++: 1979–1991

Stroustrup on how writing a simulator in Simula for his PhD shaped C++. The first few pages are the story told in section 1.1.

stroustrup.com JEP · section 8.3

JEP 361 — Switch Expressions

The design of switch expressions: the arrow form, yield, and exhaustiveness.

openjdk.org JEP · section 8.4

JEP 441 — Pattern Matching for switch

Type patterns, guards with when, and the rules that make a pattern switch exhaustive.

openjdk.org JEP · section 8.5

JEP 440 — Record Patterns

Deconstructing records inside a pattern, as in the grading example.

openjdk.org PEP · section 8.4

PEP 636 — Pattern matching tutorial

Python's match, including guards and matching on your own classes.

peps.python.org

M1Classes in Java and Python, side by side

Reference, not reading.

Idea	Java	Python
declare a class	public class Foo { … }	class Foo:
create an object	Foo f = new Foo();	f = Foo()
constructor	a method named after the class, no return type	def __init__(self, …):
none written	a default constructor is supplied — until you write one	an `__init__` always exists
instance data	declared as fields in the class	created in `__init__` through `self.`
the current object	`this` — implicit	`self` — an explicit first parameter
class-level data	`static` field, one copy	a variable in the class body
method with no object	`static` method	static method, or `@classmethod` with `cls`
hide a member	`private`, checked by the compiler	`__name`: renamed, not truly private
text form of an object	`toString()`	`__str__`
operators on your class	not available	`__add__`, `__lt__`, …
add an attribute at run time	impossible	possible — and a bad idea
enum	`enum Suit { HEARTS, … }` — a class with fixed instances	`class Suit(Enum): HEARTS = 1` — values can be anything
same object?	`a == b`	`a is b`

03 · This week

What to actually do

On Ed, work through the five Week 5 lessons. This order matches the sections above:

Fundamentals of Object Oriented Programming — section 1
Classes and Objects in Java — sections 2 to 4, including the four pizza-shop parts and their forkable workspaces
Classes and Objects in Python — sections 5 and 6
Enums in Java (and Python sort of) — section 7
Advanced switch Statements in Java — section 8

Run the new Java on Ed

Records, switch expressions, pattern matching and when need Java 14 to 22; this page’s console runs Java 8. Those examples are printed with their real output — paste them into Ed to run them, and change them.

Deadlines

Assessed lab exercises are due 11:55pm the Monday of the following week, and you must pass all test cases in an exercise to get its marks. Canvas → Assignments is authoritative for what is due and when; where this page differs, Canvas and the announcements win.

If you only do one thing

Write one small class of your own from nothing — private data, a constructor, two methods — and use it from a main in another class. Then do it again in Python. Everything from here on is built out of that.

Sources

Everything cited on this page

The lecture content comes from the Week 5 lessons on Ed. The links below are for the claims this page adds around them — checking a source yourself is a better habit than trusting any lecture slide, including ours.

Specifications and documentation

Used in	Source
1.4	The Java Language Specification, Java SE 25, §4.2.3 — `float` is IEEE 754 binary32; the 0.0625 spacing at 1,000,000 is `Math.ulp(1000000f)`, run on JDK 26
3.1	JLS §8.3.1.1 — “exactly one incarnation of the field”
4.1	The Java Virtual Machine Specification, Java SE 25, §2.5.4 — the method area
4.2	JLS §8.8.9 — “If a class contains no constructor declarations, then a default constructor is implicitly declared”
2–4	Oracle — Classes, The Java Tutorials
6.3	The Python Tutorial, §9.6 Private Variables — name mangling and the `_spam` convention
7.2	Oracle — Enums, J2SE 5.0 language guide — the int enum pattern, “Not typesafe”
7.3	JLS §8.9 — “An enum class has no instances other than those defined by its enum constants.”
7.7	Python — Enum HOWTO (aliases; `isinstance` of members); PEP 435 (enum added in Python 3.4)
8.3–8.5	JEP 361 (switch expressions, JDK 14); JEP 441 (pattern matching for switch, JDK 21); JEP 440 (record patterns, JDK 21); JEP 456 (unnamed variables and patterns, JDK 22)
8.4	PEP 636 — Structural Pattern Matching: Tutorial — guards

Quotations

Every quotation on this page was checked against a primary source — the original paper or documentation, not a quotation website.

Used in	Source
1.1	Bjarne Stroustrup, A History of C++: 1979–1991, ACM HOPL-II, 1993, §1 Introduction
1.1	2001 and 2003 Turing Award citations, as listed in Wikipedia — Turing Award
6.3	The Python Tutorial, §9.6 Private Variables

Photographs

From Wikimedia Commons, reused under the licence each one names. Author and licence come from the Commons API rather than from anyone’s memory — see media/fetch-photo.py.

Image	Source
cookie-cutter	Apple Shaped Cookies (14888835148) — Personal Creations, 2014 · CC BY 2.0
playing-cards	Playing Cards - number fives — Sudzie, 2021 · CC BY-SA 4.0
kristen-nygaard	Kristen-Nygaard-SBLP-1997-head — Jorge Stolfi, 1997 · public domain
stroustrup	Bjarne Stroustrup (2013) — ICPCNews (photographer Victor Zavyalov), 2013 · CC BY 2.0

Articles

Used in	Source
1.1	Simula — Stroustrup and Gosling acknowledging Simula as a major influence

Classes, Objects and Enums

The lecture, then the practice

01The ideas behind OOP

1.1A brief history

1.2The four pillars

1.3Encapsulation

1.4Abstraction — and we tested the claim

1.5Inheritance and polymorphism, briefly

02Classes and objects in Java

2.1The dot operator, said out loud

2.2Classes are templates for objects

2.3A class with data and methods

2.4Classes are types

03static: the class itself

3.1One copy, shared by every object

3.2Static methods

3.3What a static method cannot see

04Constructors, this, and objects in memory

4.1What an object is, in memory

4.2new and constructors

4.3this

4.4Two variables, one object — again

4.5The pizza shop, with classes

05Classes and objects in Python

5.1Roughly Java’s model

5.2Classes and objects

5.3Attributes, and three kinds of method

5.4__init__ and instance data

06Dunder methods and open doors

6.1“Dunder” methods

6.2Horrible things you can do in Python

6.3How to stop (some of) that

07Enums

7.1Enumerated types

7.2Enums in Java

7.3== is safe on enums

7.4Switching on an enum

7.5Enums are classes, so they can have methods

7.6The deck of cards

7.7Python enums (sort of)

7.8And in C, just numbers

08Advanced switch

8.1Stretching the old switch

8.2Why the rest will not run on this page

8.3Switch expressions

8.4Pattern matching and when

8.5Record patterns, _, and a switch with no default

09Coding exercises

10Team activity

Nouns and verbs: design a library

Break the encapsulation

int constants versus an enum

11Quiz

12Further reading

The official word

Classes and objects

Enum types

Python classes

Enum HOWTO

Behind the claims on this page

A History of C++: 1979–1991

JEP 361 — Switch Expressions

JEP 441 — Pattern Matching for switch

JEP 440 — Record Patterns

PEP 636 — Pattern matching tutorial

M1Classes in Java and Python, side by side

What to actually do

Everything cited on this page

Specifications and documentation

Quotations

Photographs

Articles

04Constructors, `this`, and objects in memory

4.2`new` and constructors

4.3`this`

5.4`init` and instance data

7.3`==` is safe on enums

08Advanced `switch`

8.4Pattern matching and `when`

8.5Record patterns, `_`, and a switch with no default