Why inheritance is used in Java - Why It Works This Way

Overview - Why inheritance is used

What is it?

Inheritance is a way in Java to create a new class based on an existing class. The new class, called a child or subclass, gets all the features of the existing class, called the parent or superclass. This helps reuse code and organize related classes in a clear way. It allows the child class to add or change behaviors from the parent class.

Why it matters

Without inheritance, programmers would have to write the same code again and again for similar classes, which wastes time and causes mistakes. Inheritance helps keep code simple and easy to maintain by sharing common features. It also helps build programs that are easier to understand and extend as needs grow.

Where it fits

Before learning inheritance, you should understand basic Java classes and objects. After inheritance, you can learn about polymorphism, interfaces, and design patterns that use inheritance to create flexible programs.

Mental Model

Core Idea

Inheritance lets a new class borrow code and behavior from an existing class to avoid repeating work and to build relationships.

Think of it like...

Inheritance is like a family recipe passed down from parents to children. The child can use the original recipe as is or add their own twist to make it better or different.

Superclass (Parent)
┌───────────────┐
│   Animal      │
│ - eat()       │
│ - sleep()     │
└──────┬────────┘
       │ inherits
       ▼
Subclass (Child)
┌───────────────┐
│   Dog         │
│ - bark()      │
│ - eat()       │ (inherited)
│ - sleep()     │ (inherited)
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Objects

Concept: Before inheritance, you must know what classes and objects are in Java.

A class is like a blueprint for creating objects. For example, a class 'Car' defines what a car is and what it can do. An object is a specific car made from that blueprint. You write methods inside classes to describe actions the objects can perform.

Result

You can create objects from classes and call their methods to perform actions.

Knowing classes and objects is essential because inheritance builds on these concepts by letting one class extend another.

2

Foundation

Basic Syntax of Inheritance

Concept: Java uses the keyword 'extends' to create a subclass from a superclass.

Example: class Animal { void eat() { System.out.println("Eating"); } } class Dog extends Animal { void bark() { System.out.println("Barking"); } } Dog dog = new Dog(); dog.eat(); // inherited method

Result

The Dog object can use both bark() and eat() methods.

Inheritance lets the subclass automatically have the methods of the superclass without rewriting them.

3

Intermediate

Code Reuse Through Inheritance

🤔Before reading on: Do you think inheritance copies code or shares code between classes? Commit to your answer.

Concept: Inheritance allows subclasses to reuse code from superclasses, reducing duplication.

Instead of writing the same methods in multiple classes, you write them once in a superclass. Subclasses inherit these methods and can use or override them. This saves time and reduces errors.

Result

Less code to write and maintain, with shared behavior across related classes.

Understanding that inheritance shares behavior helps you design cleaner and more maintainable code.

4

Intermediate

Extending and Overriding Behavior

🤔Before reading on: Can a subclass change how a method from its superclass works? Commit to yes or no.

Concept: Subclasses can add new methods or change existing ones from the superclass by overriding them.

Example: class Animal { void sound() { System.out.println("Some sound"); } } class Dog extends Animal { @Override void sound() { System.out.println("Bark"); } } Dog dog = new Dog(); dog.sound(); // prints 'Bark'

Result

The Dog class changes the sound() method to make a bark instead of the generic sound.

Knowing how to override methods lets you customize inherited behavior for specific needs.

5

Intermediate

Inheritance and Type Relationships

Concept: Inheritance creates an 'is-a' relationship between classes, which helps with organizing and using objects.

If Dog extends Animal, then Dog is an Animal. This means you can use a Dog object anywhere an Animal is expected. This is useful for writing flexible code that works with many related types.

Result

You can write methods that accept the superclass type and pass any subclass object to them.

Understanding 'is-a' relationships helps you design programs that are easier to extend and maintain.

6

Advanced

Avoiding Inheritance Pitfalls

🤔Before reading on: Is it always good to use inheritance for code reuse? Commit to yes or no.

Concept: Inheritance can cause problems if used incorrectly, such as tight coupling or fragile code.

Overusing inheritance can make code hard to change because subclasses depend heavily on superclasses. Sometimes composition (using objects inside other objects) is better. Also, deep inheritance trees can confuse readers and cause bugs.

Result

Knowing when not to use inheritance helps keep code clean and flexible.

Recognizing inheritance limits prevents common design mistakes that cause maintenance headaches.

7

Expert

Inheritance and Polymorphism in Practice

🤔Before reading on: Does inheritance alone enable polymorphism, or is something else needed? Commit to your answer.

Concept: Inheritance combined with method overriding enables polymorphism, letting code work with objects of different classes through a common interface.

Polymorphism means a variable of superclass type can refer to subclass objects, and the correct overridden method runs at runtime. This allows flexible and extensible code. Example: Animal a = new Dog(); a.sound(); // calls Dog's sound()

Result

Code can treat different subclasses uniformly while preserving their unique behaviors.

Understanding how inheritance enables polymorphism is key to mastering object-oriented design.

Under the Hood

At runtime, Java stores class information including methods and fields in a structure called the class hierarchy. When a subclass object calls a method, the JVM looks first in the subclass for that method. If not found, it searches up the superclass chain until it finds the method. This dynamic lookup allows method overriding and polymorphism.

Why designed this way?

Inheritance was designed to promote code reuse and model real-world relationships naturally. Early object-oriented languages showed that sharing behavior through class hierarchies reduces duplication and improves organization. Alternatives like composition exist, but inheritance remains a core concept for expressing 'is-a' relationships.

┌───────────────┐
│   Object      │
│ (root class)  │
└──────┬────────┘
       │
┌──────┴────────┐
│   Animal      │
│ - eat()       │
└──────┬────────┘
       │
┌──────┴────────┐
│   Dog         │
│ - bark()      │
└───────────────┘

Method call lookup:
Dog object -> Dog class methods
If not found -> Animal class methods
If not found -> Object class methods

Myth Busters - 4 Common Misconceptions

Quick: Does inheritance copy all code from the parent class into the child class? Commit to yes or no.

Common Belief: Inheritance copies all the code from the parent class into the child class, making a full duplicate.

Reality: Inheritance does not copy code; it creates a link so the child class can use the parent's code dynamically at runtime.

Why it matters: Thinking inheritance copies code can lead to misunderstandings about memory use and how changes in the parent affect children.

Quick: Can inheritance be used to share code between unrelated classes? Commit to yes or no.

Common Belief: Inheritance is a good way to share code between any classes, even if they are not related.

Reality: Inheritance should only be used to model 'is-a' relationships between related classes. For unrelated classes, composition or interfaces are better.

Why it matters: Misusing inheritance for code sharing can cause confusing class hierarchies and fragile code.

Quick: Does overriding a method in a subclass remove the original method from the superclass? Commit to yes or no.

Common Belief: When a subclass overrides a method, the original method in the superclass is removed or replaced everywhere.

Reality: Overriding only changes the method behavior for subclass instances; the superclass method remains unchanged and can be called explicitly if needed.

Why it matters: Misunderstanding this can cause bugs when expecting superclass behavior to be lost or changed globally.

Quick: Is inheritance the only way to achieve polymorphism in Java? Commit to yes or no.

Common Belief: Inheritance is the only way to get polymorphism in Java.

Reality: Polymorphism can also be achieved using interfaces, which allow unrelated classes to share behavior contracts without inheritance.

Why it matters: Believing inheritance is the only way limits design choices and can lead to rigid code.

Expert Zone

1

Java allows only single inheritance of classes but multiple inheritance of interfaces, which balances reuse and complexity.

2

The 'super' keyword lets subclasses call superclass methods explicitly, enabling method extension rather than full replacement.

3

Inheritance affects access control: private members are not inherited directly, which influences class design and encapsulation.

When NOT to use

Avoid inheritance when classes do not share a clear 'is-a' relationship or when you want to change behavior at runtime. Use composition (has-a relationships) or interfaces instead for more flexible and decoupled designs.

Production Patterns

Inheritance is used in frameworks to provide base classes with common functionality, letting developers extend and customize behavior. It is also key in implementing polymorphic collections and event handling systems.

Connections

Composition over Inheritance

Alternative approach

Knowing when to use composition instead of inheritance helps create more flexible and maintainable code by favoring object relationships over class hierarchies.

Polymorphism

Builds on inheritance

Understanding inheritance is essential to grasp polymorphism, which allows objects of different classes to be treated uniformly through shared interfaces.

Biological Evolution

Analogous pattern

Inheritance in programming mirrors biological inheritance where offspring inherit traits from parents, showing how natural systems inspired software design.

Common Pitfalls

#1 Using inheritance to share code between unrelated classes.

Wrong approach:

class Car extends Animal {
void drive() { System.out.println("Driving"); }
}

Correct approach:

class Car {
void drive() { System.out.println("Driving"); }
}

class Animal {
void eat() { System.out.println("Eating"); }
}

Root cause:

Confusing code reuse with 'is-a' relationships leads to improper inheritance use.

#2 Overriding a method but forgetting to call the superclass method when needed.

Wrong approach:

class Dog extends Animal {
@Override
void eat() {
System.out.println("Dog eats differently");
}
}

Correct approach:

class Dog extends Animal {
@Override
void eat() {
super.eat(); // call parent method
System.out.println("Dog eats differently");
}
}

Root cause:

Not understanding how to extend behavior rather than replace it causes loss of important functionality.

#3 Creating deep inheritance chains without clear design.

Wrong approach:

class A {}
class B extends A {}
class C extends B {}
class D extends C {}

Correct approach:

Use interfaces or composition to avoid deep chains:
interface Movable {}
class Car implements Movable {}

Root cause:

Lack of planning and misunderstanding inheritance complexity leads to fragile code.

Key Takeaways

Inheritance lets a new class reuse code and behavior from an existing class, saving time and effort.

It models real-world 'is-a' relationships, helping organize code logically and clearly.

Subclasses can override methods to customize or extend behavior inherited from superclasses.

Inheritance enables polymorphism, allowing flexible and extensible code that works with related types uniformly.

Using inheritance wisely and knowing its limits prevents common design problems and keeps code maintainable.