Java Inheritance

What Gets Inherited

A subclass automatically inherits the non-private fields and methods of its superclass, meaning it can use them as if they were declared in the subclass itself. Private members of the superclass exist in the subclass's memory layout but are not directly accessible by name from the subclass — they can only be reached indirectly through public or protected methods the superclass provides. Constructors are never inherited, but a subclass constructor always invokes a superclass constructor (implicitly or via super(...)) before running its own body.

Single Inheritance Only, for Classes

Java deliberately supports only single inheritance for classes — a class can extend exactly one direct superclass, never more than one. This avoids the "diamond problem" that arises in languages with multiple class inheritance, where ambiguity occurs if two parent classes define a conflicting method. A class can, however, implement multiple interfaces, which is how Java achieves a safe form of multiple inheritance of type without inheriting conflicting implementation.

The Inheritance Chain and Object

Every class in Java, if it does not explicitly extend another class, implicitly extends java.lang.Object, which is why every object has methods like toString(), equals(), and hashCode() available by default. Inheritance can also be chained across multiple levels (a class extending a class that extends another class), and a subclass inherits members from every class above it in that chain.

• Use extends for a class to inherit from exactly one superclass.
• A subclass gains access to public and protected superclass members directly by name.
• Every class ultimately inherits from java.lang.Object if it extends nothing else.

Types of Inheritance in Java

Inheritance is usually described in five shapes. Java classes support three of them directly. The other two are possible only through interfaces.

• Single: one class extends one class, such as Car extends Vehicle.
• Multilevel: a chain, such as Dog extends Mammal and Mammal extends Animal. Dog inherits from both classes above it.
• Hierarchical: several classes extend the same parent, such as Car, Bike and Truck all extending Vehicle.
• Multiple: one class with two parents. Classes cannot do this, but a class can implement several interfaces: class Duck implements Flyer, Swimmer.
• Hybrid: a mix of the shapes above. Java allows it only when the multiple-parent part uses interfaces.

Constructor Order in an Inheritance Chain

When you create a subclass object, the constructors run from the top of the chain down. Each constructor first calls its parent's constructor through super(...), written by you or inserted by the compiler, so the Object part is built first, then each parent, and the subclass last. This guarantees that inherited fields are set up before the subclass code uses them. In the multilevel example below, creating a Dog prints the Animal, Mammal and Dog constructor messages in that order.

Access Modifiers Across the Hierarchy

The access modifier on a member decides whether a subclass can use it by name.

• public: visible to the subclass and to everyone else.
• protected: visible to subclasses, even in other packages, and to classes in the same package. Use it for members meant for subclasses.
• Default (no modifier): visible only to subclasses in the same package.
• private: never visible by name in a subclass. Reach it through a public or protected method of the parent.

Examples

class Vehicle {
    String brand = "Generic";

    void start() {
        System.out.println(brand + " vehicle starting");
    }
}

class Car extends Vehicle {
    int numberOfDoors = 4;

    void honk() {
        System.out.println(brand + " car honking with " + numberOfDoors + " doors");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.brand = "Toyota";
        myCar.start(); // inherited from Vehicle
        myCar.honk();  // defined in Car
    }
}

Toyota vehicle starting
Toyota car honking with 4 doors

public class MultilevelDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Rex");
        dog.eat();     // from Animal
        dog.breathe(); // from Mammal
        dog.bark();    // from Dog
        System.out.println(dog instanceof Animal);
    }
}

class Animal {
    protected String name;

    Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor");
    }

    void eat() {
        System.out.println(name + " is eating");
    }
}

class Mammal extends Animal {
    Mammal(String name) {
        super(name);
        System.out.println("Mammal constructor");
    }

    void breathe() {
        System.out.println(name + " breathes air");
    }
}

class Dog extends Mammal {
    Dog(String name) {
        super(name);
        System.out.println("Dog constructor");
    }

    void bark() {
        System.out.println(name + " says woof");
    }
}

Animal constructor
Mammal constructor
Dog constructor
Rex is eating
Rex breathes air
Rex says woof
true

Exercise

Create a SavingsAccount that extends Account and adds a method addInterest(int percent), which increases the balance by that percentage. The subclass should reuse the inherited balance field.

Expected output: 1050

class Account {
    protected int balance;

    Account(int balance) {
        this.balance = balance;
    }

    int getBalance() {
        return balance;
    }
}

// TODO: class SavingsAccount extends Account, with a constructor and addInterest(int percent)

public class AccountDemo {
    public static void main(String[] args) {
        SavingsAccount savings = new SavingsAccount(1000);
        savings.addInterest(5);
        System.out.println(savings.getBalance());
    }
}

class Account {
    protected int balance;

    Account(int balance) {
        this.balance = balance;
    }

    int getBalance() {
        return balance;
    }
}

class SavingsAccount extends Account {

    SavingsAccount(int balance) {
        super(balance);
    }

    void addInterest(int percent) {
        balance += balance * percent / 100;
    }
}

public class AccountDemo {
    public static void main(String[] args) {
        SavingsAccount savings = new SavingsAccount(1000);
        savings.addInterest(5);
        System.out.println(savings.getBalance()); // 1050
    }
}

Quick quiz

Interview questions