Inheritance: extends, super and the constructor chain

Inheritance is building a new class on top of an existing one. The new class (the subclass) takes the fields and methods of the old one (the superclass), and adds its own things or changes some methods. In the exam this topic comes in two forms most often: output questions asking in what order the constructors print, and compile errors involving super.

Golden rules:

1. Every constructor first calls the superclass constructor. If you do not write it, the compiler adds super();.
2. Output order is top down: first Object, then the superclass, and the subclass last.
3. A private field is inherited but cannot be accessed by name. The subclass uses a getter or the field becomes protected.
4. Override: same signature, runs according to the actual type of the object. Overload: different parameters, chosen at compile time.
5. Fields are not overridden. Only methods are.

extends and the “is-a” relationship

When you write class Manager extends Employee, you are saying “every Manager is an Employee” (is-a relationship). Manager uses all of Employee’s public and protected members as if they were its own. In Java a class can extend only one class (single inheritance). If you want several types of behavior, you use an interface (week 4).

You tell when to use inheritance with the “is-a” test. “A Manager is an Employee” is true, so inheritance fits. “A Car is an Engine” is false; a car has an engine (has-a). In that case you put an Engine field inside Car (composition, week 7).

class Employee {
    private String name;
    protected double salary;     // subclasses can see it directly

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
        System.out.println("Employee ctor: " + name);
    }
    public String getName() { return name; }
    public double pay() { return salary; }
    @Override
    public String toString() { return "Employee " + name + " " + pay(); }
}

class Manager extends Employee {
    private double bonus;        // specific to Manager

    public Manager(String name, double salary, double bonus) {
        super(name, salary);     // the superclass constructor
        this.bonus = bonus;
        System.out.println("Manager ctor: bonus " + bonus);
    }
    @Override
    public double pay() { return super.pay() + bonus; }
    @Override
    public String toString() { return "Manager " + getName() + " " + pay(); }
}

Manager m = new Manager("Selin", 5000, 1500);
System.out.println(m);
System.out.println(m.pay());

Employee ctor: Selin
Manager ctor: bonus 1500.0
Manager Selin 6500.0
6500.0

In Manager’s toString we wrote getName(), not name. name is private in Employee; if you had written name inside Manager, you would get the compile error name has private access in Employee.

Constructor chaining

Constructors are not inherited. But when a subclass object is created, the superclass part has to be built too. That is why every constructor calls a superclass constructor on its first line:

• If you write super(arguments), that constructor is called.
• If you write nothing, the compiler secretly adds super(); (no arguments).
• If the superclass has no no-argument constructor, this hidden call gives a compile error.

class A { A() { System.out.println("A"); } }
class B extends A { B() { System.out.println("B"); } }      // hidden super()
class C extends B { C() { super(); System.out.println("C"); } }
new C();

A
B
C

new C()
  C() called → first job super() → B()
      B() called → first job super() → A()
          A() called → super() → Object() (silent)
          A body: "A"
      B body: "B"
  C body: "C"

PITFALL · this(...) and super(...) together. A constructor starts with either this(...) or super(...), never both. A constructor that starts with this(...) does not call the superclass itself; the constructor at the end of the chain does. The Truck example below shows this.

class Vehicle {
    int wheels;
    Vehicle(int w) { wheels = w; System.out.println("Vehicle " + w); }
    Vehicle()      { this(4);    System.out.println("Vehicle()"); }
}
class Bike  extends Vehicle { Bike()  { super(2); System.out.println("Bike"); } }
class Truck extends Vehicle { Truck() {           System.out.println("Truck"); } }

Bike b = new Bike();
Truck t = new Truck();
System.out.println(b.wheels + " " + t.wheels);

Vehicle 2
Bike
Vehicle 4
Vehicle()
Truck
2 4

When are field initializers assigned?

When an object is created, the order is: (1) all fields get default values (0, null, false), (2) super(...) runs, (3) this class’s field initializers (int x = 7;) are assigned, (4) the rest of the constructor body runs. If a superclass constructor calls an overridden method, that method sees the subclass’s fields still at their default values:

class Base {
    Base() { System.out.println("Base ctor"); hello(); }
    void hello() { System.out.println("Base hello"); }
}
class Derived extends Base {
    int x = 7;
    Derived() { System.out.println("Derived ctor x=" + x); }
    @Override void hello() { System.out.println("Derived hello x=" + x); }
}
new Derived();

Base ctor
Derived hello x=0
Derived ctor x=7

PITFALL · the super(...) first-line rule. The textbook and the exam follow the rule that the super(...) call must be the first line of the constructor; that is the case in Java 24 and earlier. The flexible constructor bodies feature in Java 25 allowed lines before it that do not touch this (if you compile with --release 21 you get the error flexible constructors is not supported). If you see an option in the exam like “super is not on the first line”, answer by the old rule: compile error.

protected and access

protected is convenient but loosens encapsulation a bit. In most cases keeping the field private and providing a getter is better; in the exam both solutions are accepted.

Overriding and overloading

The two concepts are confused because of their names, but they are completely different mechanisms:

class Printer {
    void show(int a)    { System.out.println("int " + a); }
    void show(double a) { System.out.println("double " + a); }
    void show(String s) { System.out.println("String " + s); }
}
Printer pr = new Printer();
pr.show(3);
pr.show(3.0);
pr.show('A');     // char widens to int
pr.show(5L);      // long widens to double
pr.show("3");

int 3
double 3.0
int 65
double 5.0
String 3

Inside an overridden method you can call the superclass version with super.method(). This is the standard way to add on top without rewriting the code:

class Shape  { String name() { return "shape"; } }
class Circle extends Shape {
    @Override String name() { return "circle<" + super.name() + ">"; }
}
System.out.println(new Circle().name());

circle<shape>

Field hiding

If a subclass declares a field with the same name as the superclass, there are two separate fields. Which field is read is decided by the type of the variable, not of the object. For methods, the actual type of the object decides.

class P { String tag = "P"; String getTag() { return tag; } }
class Q extends P { String tag = "Q"; @Override String getTag() { return tag; } }
P obj = new Q();
System.out.println(obj.tag + " " + obj.getTag());

P Q

The Object class

Every class for which you do not write extends automatically derives from java.lang.Object. So every object has these methods:

Book b1 = new Book("Dune"), b2 = new Book("Dune");   // equals NOT overridden
System.out.println(b1.equals(b2));
System.out.println(b1.getClass().getSimpleName());
System.out.println(b1 instanceof Object);

false
Book
true

final

• final class: nobody can derive from it (String and Integer are like this).
• final method: a subclass cannot override it, but overloading is free.
• final field: assigned once, then it does not change.

Common mistakes

class A { A() { System.out.println("A"); } }
class B extends A { B() { System.out.println("B"); } }
class C extends B { C() { super(); System.out.println("C"); } }

class Employee {
    private String name; protected double salary;
    Employee(String name, double salary) {
        this.name = name; this.salary = salary;
        System.out.println("Employee ctor: " + name);
    }
    String getName() { return name; }
    double pay() { return salary; }
}
class Manager extends Employee {
    private double bonus;
    Manager(String n, double s, double b) {
        super(n, s); bonus = b;
        System.out.println("Manager ctor: bonus " + bonus);
    }
    @Override double pay() { return super.pay() + bonus; }
}
// in main:
Manager m = new Manager("Selin", 5000, 1500);
System.out.println(m.pay());

class Vehicle {
    int wheels;
    Vehicle(int w) { wheels = w; }
}
class Car extends Vehicle {
    Car() { System.out.println("Car"); }
}

class Employee {
    private double salary = 100;
}
class Manager extends Employee {
    double pay() { return salary * 2; }
}

class Printer {
    void show(int a)    { System.out.println("int " + a); }
    void show(double a) { System.out.println("double " + a); }
    void show(String s) { System.out.println("String " + s); }
}
// in main:
Printer p = new Printer();
p.show('A');
p.show(5L);

class Animal {
    String sound() { return "..."; }
    String describe() { return "I say " + sound(); }
}
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}
// in main:
Animal d = new Dog();
System.out.println(d.describe());

class Animal {
    public String sound() { return "..."; }
}
class Cat extends Animal {
    String sound() { return "Meow"; }
}

class Vehicle {
    int wheels;
    Vehicle(int w) { wheels = w; System.out.println("Vehicle " + w); }
    Vehicle() { this(4); System.out.println("Vehicle()"); }
}
class Bike extends Vehicle { Bike() { super(2); System.out.println("Bike"); } }
class Truck extends Vehicle { Truck() { System.out.println("Truck"); } }
// in main:
Bike b = new Bike();
Truck t = new Truck();
System.out.println(b.wheels + " " + t.wheels);

class Base {
    Base() { System.out.println("Base ctor"); hello(); }
    void hello() { System.out.println("Base hello"); }
}
class Derived extends Base {
    int x = 7;
    Derived() { System.out.println("Derived ctor x=" + x); }
    @Override void hello() { System.out.println("Derived hello x=" + x); }
}
// in main:
new Derived();

class P { String tag = "P"; String getTag() { return tag; } }
class Q extends P { String tag = "Q"; @Override String getTag() { return tag; } }
// in main:
P obj = new Q();
System.out.println(obj.tag + " " + obj.getTag());

public class Student extends Person {
    private double gpa;

    public Student(String name, double gpa) {
        super(name);          // first line
        this.gpa = gpa;
    }
    public double getGpa() { return gpa; }

    @Override
    public String toString() {
        return super.toString() + ", GPA " + gpa;
    }
}