Inheritance with extends

Why inheritance?

A bank has savings accounts, current accounts and fixed deposits. All have an account number, an owner and a balance, and can show a statement. Copying that code into three classes means fixing every bug three times. Inheritance puts the shared part in one superclass (parent) and lets subclasses (children) add only what is different.

public class Account {
    private final String number;
    protected double balance;            // visible to subclasses (see topic 5)

    public Account(String number, double opening) {
        this.number = number;
        this.balance = opening;
    }
    public void deposit(double amt) { balance += amt; }
    public String getNumber() { return number; }
    public double getBalance() { return balance; }
}

public class SavingsAccount extends Account {
    private final double ratePercent;

    public SavingsAccount(String number, double opening, double ratePercent) {
        super(number, opening);          // run the parent's constructor first
        this.ratePercent = ratePercent;
    }
    public void addInterest() {
        balance += balance * ratePercent / 100;   // uses the inherited field
    }
}

SavingsAccount s = new SavingsAccount("SB-101", 10000, 4);
s.deposit(2000);        // inherited method
s.addInterest();        // its own method
System.out.println(s.getBalance());   // 12480.0

super(...) in constructors

Constructors are not inherited. A subclass constructor must first let the parent initialise its part, by calling super(...) with the right arguments. If you write no super call, Java inserts super() (the parent's no-argument constructor), which fails to compile if the parent does not have one. Traditionally super(...) must be the first statement; newer Java versions (25 and later) relax this slightly for statements that do not use this.

What is inherited

• Public and protected fields and methods are inherited and usable in the subclass.
• Private members exist inside the object but the subclass cannot touch them directly; it uses the parent's public or protected methods.
• Constructors are NOT inherited.
• Static members belong to the class and are accessible but not "overridden".

Single inheritance and Object

A Java class can extend exactly one class (class C extends A, B is not allowed). This avoids the confusion of a method inherited from two parents. A class can still implement many interfaces (topic 4). Every class without an extends clause automatically extends java.lang.Object, which is why every object has toString, equals and hashCode.