Composition, enum and passing references to methods

This week has three topics, and all three are about how objects relate to each other. Composition means having other objects inside an object (an employee’s birth date, a car’s engine). enum safely represents a fixed and limited set of values (days, levels, planets). Finally, you will learn exactly what changes and what does not change when you pass objects to a method. This third topic is the sneakiest source of “what is printed?” questions on the final exam.

Golden rules:

1. Composition = has-a. A field of a class can be an object of another class.
2. enum constants are not created with new, they are used as Day.WED and compared with ==.
3. Java is always pass-by-value. For objects the thing copied is the reference.
4. A method can change the inside of an object; it cannot turn the caller’s variable into another object.
5. == checks whether it is the same object, equals checks the contents (if overridden).

Composition: the has-a relationship

class Date {
    private int day, month, year;
    public Date(int day, int month, int year) {
        this.day = day; this.month = month; this.year = year;
    }
    public int getYear() { return year; }
    public String toString() { return day + "/" + month + "/" + year; }
    ...
}
class Employee {
    private String name;
    private Date birthDate;                  // an object of another class
    public Employee(String name, Date birthDate) {
        this.name = name;
        this.birthDate = birthDate;
    }
    public Date getBirthDate() { return birthDate; }
    public String toString() { return name + ", born " + birthDate; }
}
// in main:
Date birth = new Date(14, 3, 2005);
Employee e = new Employee("Deniz", birth);
System.out.println(e);
System.out.println(e.getBirthDate().getYear());

Deniz, born 14/3/2005
2005

• When Employee’s toString concatenated birthDate with a String, Date’s toString was called automatically.
• e.getBirthDate().getYear() is a chain: first get the Date object, then call its method.
• If the sentence “an employee has a date” sounds right, composition is the right choice.

The second example, handing the job to the inner object (delegation):

class Engine {
    private int cc;
    public Engine(int cc) { this.cc = cc; }
    public int getCc() { return cc; }
    public void setCc(int cc) { this.cc = cc; }
    public void run() { System.out.println("Engine " + cc + "cc running"); }
}
// Car: private String model; private Engine engine; start() { print(model + ": "); engine.run(); }
Car car = new Car("Egea", new Engine(1400));
car.start();
System.out.println(car.getEngine().getCc());

Egea: Engine 1400cc running
1400

PITFALL · a getter hands out the inner object. getBirthDate() returns not a copy of the Date but its reference. Also, the Date object given to the constructor was not copied either: the same reference was stored. When dd.setYear(1990) was done outside, the employee’s birth year also became 1990 (in verification e2.getBirthDate().getYear() → 1990). Even if the field is private, if you share a changeable inner object you cannot protect its inside.

enum

Some variables can take only one of a few values: the day of the week, a traffic light, a difficulty level. Keeping these with an int (0 = Monday) or a String ("Mon") invites mistakes: nothing stops anyone from writing day = 9 or "mon". enum defines this set as a type:

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

Day d = Day.WED;
System.out.println(d + " " + d.ordinal() + " " + d.name());
System.out.println(d == Day.WED);
for (Day x : Day.values()) System.out.print(x + " ");
System.out.println();
System.out.println(Day.values().length);
System.out.println(Day.valueOf("FRI").ordinal());

WED 2 WED
true
MON TUE WED THU FRI SAT SUN 
7
4

new Day() cannot be written: enum classes may not be instantiated. The constants are created once at the start of the program, that is all.

switch with an enum

static String advice(Level lv) {
    switch (lv) {
        case LOW: return "Devam";       // just LOW, not Level.LOW
        case MEDIUM: return "Dikkat";
        case HIGH: return "Dur";
        default: return "?";
    }
}
// main: advice(Level.LOW) + " " + advice(Level.HIGH)

Devam Dur

An enum with fields and a constructor

An enum is actually a special class; it can have fields, a constructor and methods. Each constant calls the constructor with its own argument:

enum Coin {
    QUARTER(25), HALF(50), LIRA(100);     // ; after the constants
    private final int kurus;
    Coin(int k) { kurus = k; }            // the constructor is not written public
    public int getKurus() { return kurus; }
}
// in main:
for (Coin c : Coin.values()) System.out.print(c + "=" + c.getKurus() + " ");
System.out.println();
int total = Coin.HALF.getKurus() * 2 + Coin.QUARTER.getKurus();
System.out.println(total);

QUARTER=25 HALF=50 LIRA=100 
125

Passing references to methods

In Java everything is pass-by-value: a copy of a value goes to the method. For a primitive, the thing copied is the number itself. For an object, the thing copied is the reference (the address of the object). This single rule has three consequences:

static void rename(Pet p) { p.setName("Boncuk"); }                        // 1) change the inside
static void replace(Pet p) { p = new Pet("Yeni"); p.setName("Degisti"); }  // 2) turn it into a new object
static void swap(Pet a, Pet b) { Pet t = a; a = b; b = t; }               // 3) swap
// in main:
Pet pet = new Pet("Pamuk");
rename(pet);
System.out.println(pet.getName());
replace(pet);
System.out.println(pet.getName());
Pet a = new Pet("A"), b = new Pet("B");
swap(a, b);
System.out.println(a.getName() + " " + b.getName());

Boncuk
Boncuk
A B

rename call:
  main.pet ──┐
             ├──► [Pet: "Pamuk" → "Boncuk"]     the same object, its inside changed
  rename.p ──┘

replace call:
  main.pet ─────► [Pet: "Boncuk"]               untouched
  replace.p ────► [Pet: "Degisti"]              a new object, lost when the method ends

If you want to get a new object from a method, return it: Pet m = make("Minnos");.

When you see a question of this kind in the exam, ask yourself for each method call: is the method doing a setter or an element assignment through the parameter (the caller sees it), or is it assigning to the parameter itself (the caller does not see it)? This single question decides the answer.

== and equals

Pet x1 = new Pet("Tom"), x2 = new Pet("Tom");
System.out.println((x1 == x2) + " " + x1.equals(x2));
Point p1 = new Point(1, 2), p2 = new Point(1, 2);
System.out.println((p1 == p2) + " " + p1.equals(p2));

false false
false true

Pet did not override equals; the default equals from Object does the same thing as ==. Point, on the other hand, defined equals itself and compares x and y:

@Override
public boolean equals(Object o) {
    if (!(o instanceof Point)) return false;
    Point other = (Point) o;
    return x == other.x && y == other.y;
}

String’s equals is also a method overridden like this; that is why "abc".equals(s) looks at the contents.

Common mistakes

Employee q = new Employee("Ece", new Date(5, 9, 2004));
System.out.println(q.getBirthDate().getMonth() + q.getBirthDate().getDay());

System.out.println(Day.MON.ordinal() + Day.SUN.ordinal() + " " + Day.values()[2]);

Level lv = Level.MEDIUM;
switch (lv) {
    case LOW: System.out.print("L");
    case MEDIUM: System.out.print("M");
    case HIGH: System.out.print("H");
}

Pet q = new Pet("Zeytin");
Pet q2 = q;
rename(q2);
System.out.println(q.getName());

Pet q = new Pet("Fistik");
replace(q);
rename(q);
replace(q);
System.out.println(q.getName());

static void modify(int[] arr, int v) { arr[0] = 100; v = 100; }
// in main:
int[] nums = {1, 2, 3};
int k = 5;
modify(nums, k);
System.out.println(nums[0] + " " + k);

Car c = new Car("Clio", new Engine(1000));
Engine en = c.getEngine();
en.setCc(1600);
System.out.println(c.getEngine().getCc());

System.out.println(Coin.valueOf("QUARTER").getKurus() + Coin.values().length);

Point a = new Point(3, 4), b = new Point(3, 4), c = a;
System.out.println((a == b) + " " + a.equals(b) + " " + (a == c));