Classes as blueprints

Written Explanation

The blueprint and the things built from it

Think of a form template. The template says: this form has a name field, a date field, and a signature box. It is written once. When 200 people fill it in, you get 200 filled-in forms. Each has the same shape, but different values.

The Java tutorial uses a bicycle: many bicycles of the same model are built from the same set of blueprints, and each real bicycle is an instance of the class of bicycles. The same applies in software:

Instance and object mean the same thing in this course. "Creating an object" is also called "instantiating the class".

A class in Java (preview)

class Account {
    String owner;
    int balance;
    void deposit(int amount) { balance += amount; }
    void describe() { System.out.println(owner + ": " + balance); }
}

This declares what an account is: it has an owner, a balance, and two behaviors. It does not create any account. No balance exists yet. It is only the blueprint.

To get actual accounts, use the keyword new:

Account ana = new Account();
Account omar = new Account();

Each new Account() builds a separate object. The Java tutorial describes new as allocating memory for the new object and returning a reference to it. The variable ana holds a reference to one object; omar holds a reference to another. Declaring a variable like Account x; alone does not create an object.

The dot connects a reference to the object's fields and methods: ana.balance, ana.deposit(2500).

One class, many objects, separate state

public class Two {
    public static void main(String[] args) {
        Account ana = new Account();
        ana.owner = "Ana";
        ana.balance = 10000;
        Account omar = new Account();
        omar.owner = "Omar";
        omar.balance = 5000;
        ana.deposit(2500);
        ana.describe();
        omar.describe();
    }
}

Output:

Ana: 12500
Omar: 5000

The same deposit code ran, but only on ana. Omar's balance stayed at 5000. The class is shared; the state is not.

You can also create many objects in a loop and keep them in an array, using arrays from BEG-015:

Account[] all = new Account[3];
for (int i = 0; i < all.length; i++) {
    all[i] = new Account();
    all[i].owner = "Client" + i;
}
System.out.println(all[2].owner + " " + all[2].balance);

Output: Client2 0. The balance is 0 because fields of a new object get a default value: a run on JDK 21 shows 0 for int, null for a String, and false for a boolean. (Note that new Account[3] creates an array of three empty slots; each new Account() fills one.)

This is the payoff compared to parallel arrays: 3 or 3,000 accounts, one definition.

Analogies, and where they break

• Cookie cutter and cookies: the cutter is the class; each cookie is an object. Each cookie can get its own icing (state).
• Architect's plan and houses: one plan, many houses, each with its own occupants.
• Recipe and cakes: the recipe is not edible; only the cakes are.

No analogy is perfect. A cookie cutter is a physical thing, while a class is only a description in your code; and in Java the class is also loaded and used by the running program. For this lesson the rule is enough: the class describes, the object holds values.

Quick classification rule

If you can say "one of many", it is probably an object. If you can say "the kind of thing", it is a class.

• Account is a kind of thing: class.
• "Ana's account" is one particular account: object.
• "Customer" is a kind: class. "The customer named Omar": object.