Classes and objects: review

This course continues SEN1001. In the first week we review the building blocks of object oriented programming. Inheritance, polymorphism and interfaces all reuse every concept on this page. The exam has three question types on this topic: “What is printed?” (especially static counters, references and the constructor chain), “Find the compile error” (private access, missing constructor, static context) and “Write a class”.

Golden rules:

1. A variable does not hold the object, it holds the object’s address (reference). b = a does not create a new object.
2. As soon as you write a constructor, the no-argument default constructor disappears.
3. If a field and a parameter have the same name and you do not write this., the field does not change.
4. What is static belongs to the class and has a single copy. A static method cannot access instance fields directly.
5. == compares addresses, equals compares content. (If equals is overridden.)

Class, object, field

A class is a template: it defines what data it holds (fields / instance variables) and what it can do (methods). An object is a concrete instance created from this template with new. Each object’s fields belong to it alone.

public class Account {
    private String owner;          // instance variable
    private double balance;
    private static int count = 0;  // belongs to the class, single copy

    public Account(String owner, double balance) {
        this.owner = owner;
        setBalance(balance);       // validation in one place
        count++;
    }
    public Account(String owner) {
        this(owner, 0.0);          // delegate to the other constructor
    }
    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    public double getBalance() { return balance; }
    public void setBalance(double b) {
        if (b >= 0) balance = b;
    }
    public static int getCount() { return count; }

    @Override
    public String toString() {
        return owner + " (" + balance + " TL)";
    }
}

Account a = new Account("Ece", 100);
Account b = new Account("Mert");
a.deposit(50);
a.deposit(-20);      // rejected
b.setBalance(-5);    // rejected
System.out.println(a);
System.out.println(b);
System.out.println(Account.getCount());

Ece (150.0 TL)
Mert (0.0 TL)
2

When you write System.out.println(a), Java automatically calls a.toString(). If you had not overridden toString, something like Account@1b6d3586 would be printed, the class name and the hash code; this number can change on every run.

Default values

If you do not assign a value to a field, Java gives it a default value. It does not do so for local variables (the ones inside methods); reading one before assigning it is a compile error.

Constructor

A constructor runs once when an object is created and gives the fields their initial values. Its name is the same as the class and it has no return type (not even void; if you write it, it becomes an ordinary method).

• If you write no constructor at all, the compiler adds an empty, no-argument default constructor.
• If you write even a single constructor, this addition is not made. new Car() no longer compiles.
• A class can have several constructors with different parameter lists (overloading).

The this keyword

this is the object currently being worked on. It has two uses:

1. Resolving shadowing. If a parameter has the same name as a field, a plain name inside the method refers to the parameter. To refer to the field you write this.name.
2. Constructor chaining. this(...) calls another constructor of the same class. It must be the first line of the constructor. (The flexible constructor bodies feature that arrived with Java 25 allows lines that do not use this before it. The textbook and the exam follow the old rule: first line.)

class Box {
    int w, h;
    Box()             { this(1);    System.out.println("Box()"); }
    Box(int w)        { this(w, w); System.out.println("Box(int)"); }
    Box(int w, int h) { this.w = w; this.h = h;
                        System.out.println("Box(int,int) " + w + "x" + h); }
}
// main:
Box bx = new Box();
System.out.println(bx.w * bx.h);

Box(int,int) 1x1
Box(int)
Box()
1

new Box()
  └─ this(1)            → Box(int) starts running
       └─ this(1, 1)    → Box(int,int) runs, PRINTS, finishes
       Box(int) prints its remaining line
  Box() prints its remaining line

PITFALL · order in the chain. The call order is outside to inside, the output order is inside to outside. The last constructor called finishes first. The super(...) chain in inheritance works exactly like this (week 2).

Encapsulation

Encapsulation means making an object’s data impossible to change directly from outside. The rule is simple: fields are private, access goes through public methods. The method that reads is called a getter (getBalance), the one that changes is called a setter (setBalance). The real job of a setter is validation: it rejects values such as a negative balance, an empty name or an invalid grade. That way the object never ends up in a broken state.

TIP · put the validation in one place. Let the constructor call the setter too (setBalance(balance)). If you write the same validation in two places, one gets updated and the other is forgotten.

static and instance

class Counter {
    static int total = 0;
    int mine = 0;
    void hit() { total++; mine++; }
}
Counter c1 = new Counter(), c2 = new Counter();
c1.hit(); c1.hit(); c2.hit();
System.out.println(c1.mine + " " + c2.mine + " " + Counter.total);

2 1 3

Because main is static, you cannot directly call an instance field or instance method of the same class from main. You first have to create an object. This is the most common compile error in the first weeks: non-static variable score cannot be referenced from a static context.

References and parameter passing

In Java everything is passed by value (pass by value). The difference is what gets copied:

• For primitive types such as int and double, a copy of the number is passed. A change inside the method does not affect the outside.
• For objects, a copy of the address is passed. The method can change the fields of the object at that address, and the change is visible outside. But if it assigns another object to the parameter with new, it has only redirected its own copy.

static void fill(Cup c)    { c.ml = 250; }                   // changes the object
static void swapCup(Cup c) { c = new Cup(999); c.ml = 1; }   // only the local copy
static void bump(int n)    { n = n + 10; }                    // only the local copy

Cup cup = new Cup(100);
int n = 5;
fill(cup);
bump(n);
System.out.println(cup.ml + " " + n);
swapCup(cup);
System.out.println(cup.ml);

250 5
250

toString and equals

Every class, even if you do not write it, derives from the Object class and gets the toString() and equals(Object) methods from it. The default versions of both are often useless to you:

• Default toString(): ClassName@hashcode.
• Default equals(o): this == o, that is, an address comparison.

To compare content you override equals. The parameter type must be Object; if you write equals(Point p) it is an overload, not an override, and it will not be called where you expect.

class Point {
    private final int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;              // same object
        if (!(o instanceof Point)) return false; // wrong type or null
        Point p = (Point) o;
        return x == p.x && y == p.y;
    }
    @Override
    public String toString() { return "(" + x + ", " + y + ")"; }
}
Point p1 = new Point(2, 3), p2 = new Point(2, 3);
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));
System.out.println(p1);

false
true
(2, 3)

String follows the same logic. "java" == new String("java") gives false, equals gives true. Because String literals are kept in a shared pool (string pool), == between two literals sometimes comes out true; that is luck, do not rely on it.

PITFALL · write @Override. If you put @Override on a method, the compiler warns you when you get the signature wrong (for example equals(Point o) or tostring()). If you do not, you have silently created a new method.

Common mistakes

class Counter {
    static int total = 0;
    int mine = 0;
    void hit() { total++; mine++; }
}
// in main:
Counter c1 = new Counter(), c2 = new Counter();
c1.hit(); c1.hit(); c2.hit();
System.out.println(c1.mine + " " + c2.mine + " " + Counter.total);

class Student {
    private String name;
    public Student(String name) { name = name; }
    public String getName() { return name; }
}
// in main:
System.out.println(new Student("Ali").getName());

Account x = new Account("Can", 10);   // deposit adds to balance
Account y = x;
y.deposit(5);
System.out.println(x.getBalance());
System.out.println(x == y);

String s1 = "java";
String s2 = new String("java");
String s3 = "java";
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
System.out.println(s1 == s3);

class Car {
    private String model;
    public Car(String model) { this.model = model; }
}
public class Test {
    public static void main(String[] args) {
        Car c = new Car();
    }
}

public class Test {
    private int score = 10;
    public static void main(String[] args) {
        System.out.println(score);
    }
}

class Defaults { int i; double d; boolean b; String s; }
// in main:
Defaults df = new Defaults();
System.out.println(df.i + " " + df.d + " " + df.b + " " + df.s);

class Box {
    int w, h;
    Box() { this(1); System.out.println("Box()"); }
    Box(int w) { this(w, w); System.out.println("Box(int)"); }
    Box(int w, int h) { this.w = w; this.h = h;
        System.out.println("Box(int,int) " + w + "x" + h); }
}
// in main:
Box bx = new Box();
System.out.println(bx.w * bx.h);

class Cup { int ml; Cup(int ml) { this.ml = ml; } }
static void fill(Cup c) { c.ml = 250; }
static void swapCup(Cup c) { c = new Cup(999); c.ml = 1; }
static void bump(int n) { n = n + 10; }
// in main:
Cup cup = new Cup(100);
int n = 5;
fill(cup);
bump(n);
System.out.println(cup.ml + " " + n);
swapCup(cup);
System.out.println(cup.ml);

class P { int x, y; P(int x, int y) { this.x = x; this.y = y; } }
// in main:
P a = new P(2, 3), b = new P(2, 3);
System.out.println(a.equals(b));

class Wallet {
    private double money = 50;
}
public class Test {
    public static void main(String[] args) {
        Wallet w = new Wallet();
        w.money = 100;
    }
}

public class Rectangle {
    private double width, height;

    public Rectangle(double width, double height) {
        setWidth(width);
        setHeight(height);
    }
    public void setWidth(double width) {
        if (width <= 0) throw new IllegalArgumentException("width must be > 0");
        this.width = width;
    }
    public void setHeight(double height) {
        if (height <= 0) throw new IllegalArgumentException("height must be > 0");
        this.height = height;
    }
    public double getArea() { return width * height; }

    @Override
    public String toString() {
        return "Rectangle[" + width + " x " + height + "]";
    }
}