Classes and Objects in Code

1A class declaration writes the mould

A class declaration is the Java sentence that names the mould. class Ticket { } says: there is a kind of thing called Ticket, and its members will live between the braces.

The file Ticket.java holds that class. You do not yet have a ticket in the hall — you have the idea written down so the machine can print many.

Figure. The file on the left is the place. The class on the right is the mould. No object exists yet.

How it works

1. A class declaration writes the mouldclass Name { } writes the mould. It is not yet a ticket in anyone's hand.

The smallest Ticket class

public class Ticket {
    // members go here
}

2Members are the facts and the work

Members live inside the class. A field is a fact the object will hold — show, seat, price. A method is work the object can do — print the stub, apply a student cut.

Fields and methods are both members. The difference is what they are for: stored facts versus behaviour.

Figure. Ticket owns two kinds of member. Fields store. Methods do work. Both sit inside the same braces.

How it works

1. Members are the facts and the workA field is a fact. A method is work. Both are members of the class.

Three fields and one method

public class Ticket {
    String show;
    String seat;
    int price;
    void printStub() {
        System.out.println(seat + " " + price);
    }
}

3new makes one object

new Ticket() asks the machine for one object of that class. Meera's variable t holds a reference to that object — a way to find it — not the paper itself.

A second new Ticket() is a second object. Two news, two tickets, even if both start with the same show.

Figure. The class is one. Each new arrow is a separate object. t and u do not share paper.

How it works

1. new makes one objectnew makes one object. Another new is another object.

Two objects from one class

Ticket t = new Ticket();
t.seat = "A12";
Ticket u = new Ticket();
u.seat = "B7";

Coding lab. Make one ticket and print its seat runs in the app, with checks on your output.

4Assignment copies the reference

Ticket u = t; does not print a second stub. It copies the reference: u now finds the same object t finds.

After that, u.seat = "C4" changes Meera's ticket. There is still one object. Two names, one seat.

Figure. Both variables point at the same object. Changing the seat through u is visible through t.

u = t shares the object

Ticket t = new Ticket();
t.seat = "A12";
Ticket u = t;
u.seat = "C4";
// t.seat is now C4 as well

5Access words decide who may touch a member

Access control is a word on a member: public, private, protected, or none. It answers who may read or write that member — not who may hold the object.

public is the desk window. private is the drawer behind the desk. No word means the rest of the same package may see it. protected also lets a subclass see it.

Figure. The window is what other classes may call. The drawer is only for Ticket's own methods. The two panels do not overlap: a caller is on one side or the other.

6Private fields, public methods

A private field cannot be read as t.price from the desk class. Ticket's own methods still can. That is encapsulation written in Java: the facts stay inside; the public methods are the only door.

Meera's desk asks t.priceAfterTax() instead of writing t.price from outside. The formula can change; the door stays.

Figure. price is private: the desk cannot read t.price. Ticket's own methods still can. The public door is priceAfterTax(). The facts stay inside.

How it works

1. Private fields, public methodsMake fields private. Offer a small public method. That is access control doing encapsulation.

price is private; the door is a method

public class Ticket {
    private int price;
    public int priceAfterTax() {
        return price + price / 10;
    }
}