Inheritance, super and Constructor Chaining

Is-a relationships

Inheritance lets a subclass (child) acquire the fields and methods of a superclass (parent) and add or change behaviour: class SavingsAccount extends Account. It models an is-a relationship: a savings account is an account. In Java every class ultimately inherits from Object; a class can extend one superclass. A subclass constructor must initialise its parent first: Java inserts a call to the parent's no-argument constructor, or you call a specific one with super(...) as the first statement. super.method() calls the parent's version of an overridden method. private members are not accessible in the subclass (they exist but are hidden); protected members are. Inheritance types often listed in syllabi: single, multilevel (A → B → C), hierarchical (several classes extend one parent), and multiple inheritance (one class with several parents), which Java does not allow for classes but C++ does; Java achieves similar flexibility with multiple interfaces.

A class hierarchy

Subclasses inherit from a parent and add their own specialised behaviour.

A subclass with constructor chaining and super calls

SavingsAccount reuses Account and adds interest.

public class Account {
    protected final String owner;
    protected double balance;

    public Account(String owner, double opening) {
        this.owner = owner;
        this.balance = opening;
    }

    public String summary() { return owner + ": " + balance; }
}

public class SavingsAccount extends Account {
    private final double ratePercent;

    public SavingsAccount(String owner, double opening, double ratePercent) {
        super(owner, opening);                    // must come first
        this.ratePercent = ratePercent;
    }

    public void addMonthlyInterest() {
        balance += balance * ratePercent / 100 / 12;   // protected field from Account
    }

    @Override
    public String summary() {
        return super.summary() + " (savings @ " + ratePercent + "%)";
    }
}

Is-a must be true in every situation

Before extending a class, check that the subclass can be used wherever the parent is expected, without surprises. "A car has an engine" is composition, not inheritance.

Quick check: In a Java subclass constructor, where must an explicit call to super(...) appear?

• As the first statement
• Anywhere in the constructor
• As the last statement
• Only in static methods