Inheritance in Java: Types and Examples

Inheritance in Java lets one class reuse and extend another. A SavingsAccount can inherit everything a BankAccount does and add interest on top, without copying any code. This guide covers how inheritance works, the types of inheritance in Java, and why a class can't extend more than one parent.

What is inheritance in Java?

Inheritance creates an "is-a" relationship: a Dog is an Animal, and a SavingsAccount is a BankAccount. The existing class is the parent (also called superclass or base class). The new class is the child (also called subclass or derived class).

You create inheritance with the extends keyword:

public class BankAccount {
    protected double balance;

    public void deposit(double amount) {
        balance += amount;
    }
}

public class SavingsAccount extends BankAccount {
    private final double rate;

    public SavingsAccount(double rate) {
        this.rate = rate;
    }

    public void addInterest() {
        balance += balance * rate;   // uses the inherited field
    }
}

SavingsAccount s = new SavingsAccount(0.05);
s.deposit(200);       // inherited from BankAccount
s.addInterest();      // defined in SavingsAccount
System.out.println(s.balance);

210.0

What is method overriding?

A child class can replace a parent's method with its own version. This is called overriding. Mark it with @Override so the compiler checks you actually matched the parent's method:

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

public class Dog extends Animal {
    @Override
    public String sound() {
        return "Woof";
    }
}

Animal pet = new Dog();            // a Dog stored in an Animal variable
System.out.println(pet.sound());   // Java calls Dog's version

Woof

Java decides which version to run based on the actual object (a Dog), not the variable type (Animal). That's polymorphism, and it's what makes inheritance powerful. To call the parent's version from inside the child, use the super keyword.

What are the types of inheritance in Java?

There are five classic types. Java supports three of them directly with classes:

class Animal { }
class Dog extends Animal { }

class Animal { }
class Dog extends Animal { }
class Puppy extends Dog { }   // Puppy is a Dog AND an Animal

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }

class Duck extends Animal, Robot { }        // ✘ compile error

class Duck implements Swimmer, Flyer { }    // ✔ fine

class Bird extends Animal implements Flyer { }
class Fish extends Animal implements Swimmer { }
class Duck extends Bird implements Swimmer { }

Why can't a Java class extend multiple classes?

Imagine Printer and Scanner both have a start() method, and Copier extends Printer, Scanner. When you call copier.start(), which one should run? This ambiguity is called the diamond problem. Java's designers avoided it by allowing only one parent class.

interface Printer { default String start() { return "printing"; } }
interface Scanner { default String start() { return "scanning"; } }

class Copier implements Printer, Scanner {
    @Override
    public String start() {
        return Printer.super.start() + " + " + Scanner.super.start();
    }
}

System.out.println(new Copier().start());

printing + scanning

Every class already inherits from Object

If a class doesn't say extends, Java quietly makes it extend java.lang.Object. That's why every object has methods like toString(), equals(), and hashCode().

How do you prevent inheritance?

• final class — can't be extended at all, like String. See the final keyword.
• final method — can be inherited but not overridden.
• sealed class (Java 17+) — only the subclasses you list are allowed: sealed class Shape permits Circle, Square.

Quick recap

What's next?

Sometimes a parent class should never be created on its own, like a generic "Shape". That's what abstract classes in Java are for. You may also want to revisit access modifiers to see how protected fits in.