Classes and objects: fields, methods, get/set

Until now you wrote everything inside main and in static methods. Real programs, however, are made of objects: accounts in a banking application, players in a game, students in a school system. Every object has its own data (fields) and its own behavior (methods). This week you will write your first classes. On the final, this topic comes as a writing question: “write a class with these fields and methods, create two objects in main”.

Golden rules:

1. A class is a template, an object is an instance. From a Dog class you can make as many dog objects as you like.
2. Every object has its own fields. Changing one does not affect another.
3. A variable holds not the object but the object’s reference. b = a does not create a new object.
4. Fields private, access through public methods (get/set).
5. Instance methods are not static and are called on an object.

The first class

class Dog {
    String name;     // instance variables (instance variables / fields)
    int age;

    void bark() {    // instance method (instance method): NO static
        System.out.println(name + " (" + age + ") says Hav!");
    }
}

A class defines a type. By itself it runs nothing; there is no main in it. The code that uses it is in the main of another class:

Dog d1 = new Dog();          // create a new object (instantiation)
d1.name = "Karabas";
d1.age = 3;
d1.bark();
Dog d2 = new Dog();
System.out.println(d2.name + " " + d2.age);
d2.name = "Pamuk";
d2.bark();
d1.bark();

Karabas (3) says Hav!
null 0
Pamuk (0) says Hav!
Karabas (3) says Hav!

Observations:

• new Dog() creates a new Dog object in memory and returns its address. d1 holds this address.
• With the dot operator you access the object’s field and method: d1.name, d1.bark().
• The name inside bark() is the field of the object that called the method. d1.bark() prints Karabas, d2.bark() prints Pamuk.
• Before d2 is given values, its fields are at their default values: String null, int 0. (Local variables inside a method have no such default.)

A file can contain several classes, but only one can be public, and the file name is its name. In real projects each class goes in its own file: Dog.java, Main.java.

Encapsulation: private fields, get and set

If the fields were public, anyone could write acc.balance = -5000;. To prevent this, the fields are made private and controlled public methods are exposed. This is called encapsulation.

class Account {
    private String owner;
    private double balance;

    public String getOwner() { return owner; }                     // get (accessor)
    public void setOwner(String newOwner) { owner = newOwner; }    // set (mutator)
    public double getBalance() { return balance; }                 // NO set for balance

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

    public void withdraw(double amount) {
        if (amount <= balance) balance -= amount;
        else System.out.println("Insufficient funds");
    }
}

Account acc = new Account();
acc.setOwner("Deniz");
acc.deposit(500);
acc.withdraw(200);
acc.withdraw(1000);
System.out.println(acc.getOwner() + " " + acc.getBalance());
acc.deposit(-50);
System.out.println(acc.getBalance());

Insufficient funds
Deniz 300.0
300.0

The balance can only change through deposit and withdraw, and both check the rules. If you try to access it directly from outside:

Acc a = new Acc();
a.balance = 1000;

Main.java:7: error: balance has private access in Acc

get/set naming

The return type of a get method is the type of the field, and it has no parameters. A set method is void, and its parameter has the type of the field. You do not have to write a set for every field: for a field like the balance that should not be changed directly, no set is written.

Validation

class Thermostat {
    private double celsius;

    public void setCelsius(double value) {
        if (value >= 5 && value <= 35) celsius = value;    // out of range is rejected
    }
    public double getCelsius() { return celsius; }
    public double getFahrenheit() { return celsius * 9 / 5 + 32; }
}
// in main:
Thermostat t = new Thermostat();
t.setCelsius(45);
System.out.println(t.getCelsius());
t.setCelsius(22.5);
System.out.println(t.getCelsius() + " " + t.getFahrenheit());

0.0
22.5 72.5

45 was rejected, the field stayed at the default 0.0. getFahrenheit is not a field, it is a value computed from a field; there is no need to store it separately.

Reference variables

A primitive variable holds the value itself. An object variable holds the object’s reference (its place in memory).

Account a = new Account();
a.deposit(100);
Account b = a;              // the reference was copied, not the object
b.deposit(50);
System.out.println(a.getBalance() + " " + b.getBalance());
System.out.println(a == b);
Account c = new Account();
c.deposit(150);
System.out.println(a == c);

150.0 150.0
true
false

a ──┐
    ├──► [Account: balance 150.0]
b ──┘
c ─────► [Account: balance 150.0]     another object

With objects, == looks not at the contents but at whether it is the same object. The balances of a and c are equal but they are different objects: false. (This is also why we use equals with Strings.)

null

The value of a reference that points to no object is null. Calling a method through a null reference crashes the program:

Account n = null;
n.deposit(10);

NullPointerException

The code compiles, because the compiler only looks at the type (Account has deposit). The error appears at run time.

The difference between static and instance methods

main is static; it does not belong to an object. Instance methods, on the other hand, belong to an object. That is why, from main, an instance method is called on an object:

Acc a = new Acc();
System.out.println(Acc.getBalance());     // with the class name: WRONG

Main2.java:8: error: non-static method getBalance() cannot be referenced from a static context

The correct way is a.getBalance(). Whose balance? a’s. The class does not have a single balance; each object has its own. You will see static fields, which all objects share, in week 12.

Worked example: a class writing question

Question: “Write a Rectangle class: private int width and height, set methods, getWidth(), methods that return the area and the perimeter.”

class Rectangle {
    private int width, height;
    public void setWidth(int w) { width = w; }
    public void setHeight(int h) { height = h; }
    public int getWidth() { return width; }
    public int area() { return width * height; }
    public int perimeter() { return 2 * (width + height); }
}

Grading is usually like this: the private declaration of the fields, the correct header of each method (the return type!), the correct formula in the body, and creating an object with new in main and calling the methods with a dot. For a 3 by 4 rectangle the area is 12 and the perimeter is 14.

Common mistakes

Counter c1 = new Counter();
Counter c2 = new Counter();
c1.increment();
c1.increment();
c2.increment();
System.out.println(c1.getCount() + " " + c2.getCount());

Counter c3 = new Counter();
Counter c4 = c3;
c3.increment();
c4.increment();
c4.increment();
System.out.println(c3.getCount());

Account a = new Account();
a.deposit(300);
a.withdraw(100);
a.withdraw(250);
a.deposit(-20);
System.out.println(a.getBalance());

Dog d = new Dog();
System.out.println(d.name + " " + d.age);

class Box {
    private int size = 1;
    public void setSize(int s) { if (s > 0) size = s; }
    public int getSize() { return size; }
    public int volume() { return size * size * size; }
}
// in main:
Box bx = new Box();
bx.setSize(4);
bx.setSize(-2);
System.out.println(bx.getSize() + " " + bx.volume());

Account p = new Account();
Account q = new Account();
p.deposit(100);
q = p;
q.deposit(25);
p = new Account();
p.deposit(5);
System.out.println(p.getBalance() + " " + q.getBalance());

Rectangle r = new Rectangle();
r.setWidth(3);
r.setHeight(4);
System.out.println(r.area() + " " + r.perimeter());
r.setWidth(r.getWidth() * 2);
System.out.println(r.area());

class Light {
    private boolean on;
    public void toggle() { on = !on; }
    public boolean isOn() { return on; }
}
// in main:
Light l = new Light();
l.toggle();
l.toggle();
l.toggle();
System.out.println(l.isOn());

Account n = null;
n.deposit(10);