Mastering Java Inheritance: How the extends Keyword Works (Complete Guide)

1. Introduction

2. What Is Java Inheritance?

About the “is-a” Relationship

class Animal {
    void eat() {
        System.out.println("食べる");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("ワンワン");
    }
}

What Happens When You Use Inheritance?

• You can centralize shared logic and data in the parent class, reducing the need to write the same code repeatedly in each subclass.
• Each subclass can add its own unique behavior or override the parent class’s methods.

3. How the extends Keyword Works

Basic Syntax

class ParentClass {
    // Fields and methods of the parent class
}

class ChildClass extends ParentClass {
    // Fields and methods unique to the child class
}

class Animal {
    void eat() {
        System.out.println("食べる");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("ワンワン");
    }
}

Using Parent Class Members

Dog dog = new Dog();
dog.eat();   // Calls the parent class method
dog.bark();  // Calls the child class method

Important Notes

• Java allows inheritance from only one class (single inheritance). You cannot specify multiple classes after extends.
• If you want to prevent inheritance, you can use the final modifier on the class.

Practical Development Tips

4. Method Overriding and the super Keyword

Method Overriding

class Animal {
    void eat() {
        System.out.println("食べる");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("ドッグフードを食べる");
    }
}

Dog dog = new Dog();
dog.eat(); // Displays: ドッグフードを食べる

Using the super Keyword

class Dog extends Animal {
    @Override
    void eat() {
        super.eat(); // Calls the parent class’s eat()
        System.out.println("ドッグフードも食べる");
    }
}

Constructors and super

class Animal {
    Animal(String name) {
        System.out.println("Animal: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
        System.out.println("Dog: " + name);
    }
}

Summary

• Overriding means redefining a parent class method in the child class.
• Using the @Override annotation is recommended.
• Use super when you want to reuse the parent class’s method implementation.
• super is also used when calling parent constructors.

5. Advantages and Disadvantages of Inheritance

Advantages of Inheritance

1. Improved code reusability Defining shared logic and data in the parent class eliminates the need to repeat the same code in each subclass. This reduces duplication and improves maintainability and readability.
2. Easier extension When new functionality is needed, you can create a new subclass based on the parent class without modifying existing code. This minimizes change impact and reduces the chance of bugs.
3. Enables polymorphism Inheritance allows “a variable of the parent class to reference an instance of the child class.” This enables flexible design using common interfaces and polymorphic behavior.

Disadvantages of Inheritance

1. Deep hierarchies make design complex If inheritance chains grow too deep, it becomes difficult to understand where behavior is defined, making maintenance harder.
2. Changes in the parent class affect all subclasses Modifying parent class behavior may unintentionally cause problems across all subclasses. Parent classes require careful design and updates.
3. Can reduce design flexibility Overusing inheritance tightly couples classes, making future changes difficult. In some cases, “has-a” relationships using composition are more flexible than “is-a” inheritance.

Summary

6. Differences Between Inheritance and Interfaces

Differences Between extends and implements

• extends (Inheritance)
• You can inherit from only one class (single inheritance).
• Fields and fully implemented methods from the parent class can be used directly in the subclass.
• Represents an “is-a relationship” (e.g., a Dog is an Animal).
• implements (Interface Implementation)
• Multiple interfaces can be implemented simultaneously.
• Interfaces contain only method declarations (though default methods exist from Java 8 onward).
• Represents a “can-do relationship” (e.g., a Dog can bark, a Dog can walk).

Example of Using Interfaces

interface Walkable {
    void walk();
}

interface Barkable {
    void bark();
}

class Dog implements Walkable, Barkable {
    public void walk() {
        System.out.println("歩く");
    }
    public void bark() {
        System.out.println("ワンワン");
    }
}

Why Interfaces Are Necessary

How to Use Them Properly

• Use extends when a clear “is-a relationship” exists between classes.
• Use implements when you want to provide common behavior contracts across multiple classes.

Examples:

• “A Dog is an Animal” → Dog extends Animal
• “A Dog can walk and can bark” → Dog implements Walkable, Barkable

Summary

• A class can inherit from only one parent class, but it can implement multiple interfaces.
• Choosing between inheritance and interfaces based on design intent leads to clean, flexible, and maintainable code.

7. Best Practices for Using Inheritance

When to Use Inheritance — and When to Avoid It

• Use inheritance when:
• A clear “is-a relationship” exists (e.g., a Dog is an Animal).
• You want to reuse parent class functionality and extend it.
• You want to eliminate redundant code and centralize common logic.
• Avoid inheritance when:
• You are using it only for code reuse (this often leads to unnatural class design).
• A “has-a relationship” is more appropriate — in such cases, consider composition.

Choosing Between Inheritance and Composition

• Inheritance (extends): is-a relationship
• Example: Dog extends Animal
• Useful when the subclass truly represents a type of the superclass.
• Composition (has-a relationship)
• Example: A Car has an Engine
• Uses an instance of another class internally to add functionality.
• More flexible and easier to adapt to future changes.

Design Guidelines to Prevent Misuse of Inheritance

• Do not make inheritance hierarchies too deep (keep to 3 levels or fewer).
• If many subclasses inherit from the same parent, re-evaluate whether the parent’s responsibilities are appropriate.
• Always consider the risk that changes in the parent class will affect all subclasses.
• Before applying inheritance, consider alternatives such as interfaces and composition.

Limiting Inheritance with the final Modifier

• Adding final to a class prevents it from being inherited.
• Adding final to a method prevents it from being overridden by subclasses.

final class Utility {
    // This class cannot be inherited
}

class Base {
    final void show() {
        System.out.println("オーバーライド禁止");
    }
}

Enhancing Documentation and Comments

• Documenting inheritance relationships and class design intentions in Javadoc or comments makes future maintenance far easier.

Summary

8. Summary

• Java inheritance allows a subclass to take over the data and functionality of a superclass, enabling efficient and reusable program design.
• The extends keyword clarifies the relationship between a parent and child class (the “is-a relationship”).
• Method overriding and the super keyword make it possible to extend or customize inherited behavior.
• Inheritance offers many advantages, such as code reuse, extensibility, and support for polymorphism, but also has drawbacks such as deep or complex hierarchies and wide-impact changes.
• Understanding the differences between inheritance, interfaces, and composition is crucial for choosing the right design approach.
• Avoid overusing inheritance; always be clear about the design intent and rationale.

9. Frequently Asked Questions (FAQ)