Inheritance in Java

Intermediate ~30 min read

Inheritance is one of the four pillars of Object-Oriented Programming. It allows a class to inherit fields and methods from another class, promoting code reuse and establishing a natural hierarchy between classes.

What is Inheritance?

Inheritance is a mechanism where a new class (called a subclass or child class) is derived from an existing class (called a superclass or parent class). The subclass inherits all non-private fields and methods from the superclass.

Key Terms:

Superclass (Parent): The class being inherited from
Subclass (Child): The class that inherits
extends: The keyword used to inherit from a class

The `extends` Keyword

In Java, you use the extends keyword to inherit from a class.

// Superclass (Parent)
class Animal {
    String name;

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

    void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// Subclass (Child) - inherits from Animal
class Dog extends Animal {
    void bark() {
        System.out.println(name + " says: Woof!");
    }
}

In this example, Dog inherits all non-private members from Animal. A Dog object can use eat(), sleep(), AND its own bark() method.

The IS-A Relationship

Inheritance establishes an IS-A relationship. If Dog extends Animal, then we can say "a Dog IS-A Animal". This relationship is fundamental to polymorphism.

Dog myDog = new Dog();
myDog.name = "Buddy";

// Dog IS-A Animal, so Dog can do everything Animal can do
myDog.eat();    // Inherited from Animal
myDog.sleep();  // Inherited from Animal
myDog.bark();   // Defined in Dog

What Gets Inherited?

A subclass inherits:

public members - accessible everywhere
protected members - accessible in subclass and same package
Default (package-private) members - only if subclass is in same package

Not Inherited:

private members - never accessible directly in subclass
Constructors - not inherited, but can be called using super()

Single Inheritance in Java

Java supports single inheritance only - a class can extend only ONE other class. This avoids the complexity of the "diamond problem" found in languages with multiple inheritance.

// Valid - single inheritance
class Dog extends Animal { }

// INVALID - multiple inheritance not allowed
// class Dog extends Animal, Pet { }  // Compile error!

Tip: While you can only extend one class, you can implement multiple interfaces. This is Java's way of achieving similar functionality to multiple inheritance.

Inheritance Hierarchy

Classes can form a chain of inheritance. Each subclass inherits from its direct parent AND all ancestors above it.

class Animal {
    void breathe() {
        System.out.println("Breathing...");
    }
}

class Mammal extends Animal {
    void warmBlooded() {
        System.out.println("I'm warm-blooded!");
    }
}

class Dog extends Mammal {
    void bark() {
        System.out.println("Woof!");
    }
}

// Dog inherits from Mammal AND Animal
Dog dog = new Dog();
dog.breathe();      // From Animal
dog.warmBlooded();  // From Mammal
dog.bark();         // From Dog

// Superclass (Parent class)
class Animal {
    String name;
    int age;

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

void sleep() {
        System.out.println(name + " is sleeping.");
    }

void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

// Subclass (Child class) - inherits from Animal
class Dog extends Animal {
    String breed;

void bark() {
        System.out.println(name + " says: Woof! Woof!");
    }

void fetch() {
        System.out.println(name + " is fetching the ball!");
    }
}

// Another subclass of Animal
class Cat extends Animal {
    boolean isIndoor;

void meow() {
        System.out.println(name + " says: Meow!");
    }

void scratch() {
        System.out.println(name + " is scratching the furniture!");
    }
}

// Multi-level inheritance example
class Mammal extends Animal {
    void warmBlooded() {
        System.out.println(name + " is warm-blooded.");
    }
}

class Whale extends Mammal {
    void swim() {
        System.out.println(name + " is swimming in the ocean.");
    }
}

public class InheritanceBasics {
    public static void main(String[] args) {
        System.out.println("=== Basic Inheritance Demo ===\n");

// Create a Dog object
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.age = 3;
        myDog.breed = "Golden Retriever";

// Dog can use inherited methods from Animal
        myDog.displayInfo();    // Inherited from Animal
        myDog.eat();            // Inherited from Animal
        myDog.sleep();          // Inherited from Animal
        myDog.bark();           // Defined in Dog
        myDog.fetch();          // Defined in Dog

System.out.println("\n=== Cat Example ===\n");

// Create a Cat object
        Cat myCat = new Cat();
        myCat.name = "Whiskers";
        myCat.age = 5;
        myCat.isIndoor = true;

myCat.displayInfo();    // Inherited from Animal
        myCat.eat();            // Inherited from Animal
        myCat.meow();           // Defined in Cat

System.out.println("\n=== Multi-level Inheritance ===\n");

// Whale extends Mammal extends Animal
        Whale whale = new Whale();
        whale.name = "Moby";
        whale.age = 20;

whale.displayInfo();    // From Animal (grandparent)
        whale.eat();            // From Animal
        whale.warmBlooded();    // From Mammal (parent)
        whale.swim();           // From Whale (own method)

System.out.println("\n=== IS-A Relationship ===\n");

// Dog IS-A Animal
        System.out.println("myDog instanceof Dog: " + (myDog instanceof Dog));
        System.out.println("myDog instanceof Animal: " + (myDog instanceof Animal));

// Cat IS-A Animal
        System.out.println("myCat instanceof Cat: " + (myCat instanceof Cat));
        System.out.println("myCat instanceof Animal: " + (myCat instanceof Animal));

// Whale IS-A Mammal IS-A Animal
        System.out.println("whale instanceof Whale: " + (whale instanceof Whale));
        System.out.println("whale instanceof Mammal: " + (whale instanceof Mammal));
        System.out.println("whale instanceof Animal: " + (whale instanceof Animal));
    }
}

Output

Click Run to execute your code

Benefits of Inheritance

Code Reuse: Write common code once in the parent class
Extensibility: Add new features without modifying existing code
Maintainability: Fix bugs in one place (parent class)
Polymorphism: Treat objects of different classes uniformly

Common Mistakes

Trying to access private members: Private fields/methods are not accessible in subclasses. Use getters/setters or protected access.
Forgetting that constructors aren't inherited: You must call the parent constructor explicitly using super() if needed.
Overusing inheritance: Use inheritance for IS-A relationships. For HAS-A relationships, use composition instead.

Summary

Inheritance allows a class to inherit fields and methods from another class using extends.
The child class (subclass) inherits from the parent class (superclass).
Inheritance establishes an IS-A relationship.
Java supports single inheritance - one class can only extend one other class.
Private members are not inherited; constructors are not inherited but can be called with super().

Previous final Keyword

Next super Keyword