What is Multilevel Inheritance in Java? Features & Code Examples

Inheritance in Java is a fundamental concept that allows one class (called the child class or subclass) to inherit the properties and behaviors of another class (called the parent class or superclass). This helps reuse code, reduce redundancy, and establish a clear hierarchical structure in a program.

Benefits of Inheritance:

1. Code Reusability: A subclass can inherit common characteristics and methods from the parent class, which reduces the need to write the same code repeatedly and improves development efficiency.
2. Method Overriding: This technique enables a child class to change or modify the implementation of a method inherited from the parent class, giving programming flexibility and adaptability.
3. Better Code Organization: By arranging similar classes in a logical hierarchy, inheritance facilitates an organized approach to development and makes it simpler to grow and manage large programs.

1. Single Inheritance

Single inheritance in Java happens when a class inherits from just one parent class. This allows the child class to reuse methods from the parent class.

Code Example:

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

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Inherited method
        dog.bark(); // Dog's own method
    }
}

Output:

Eating...  
Barking...  

2. Multilevel Inheritance

Multilevel inheritance in Java means a class inherits from another class, which itself is a subclass of another class. This forms a chain of inheritance, allowing the creation of a multilevel inheritance program in Java that indicates hierarchical relationships between classes.

Multilevel Inheritance Example in Java:

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

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

class Puppy extends Dog {
    void whine() {
        System.out.println("Whining...");
    }
}

public class Main {
    public static void main(String[] args) {
        Puppy puppy = new Puppy();
        puppy.eat();   // Inherited from Animal
        puppy.bark();  // Inherited from Dog
        puppy.whine(); // Specific to Puppy
    }
}

Output:

Eating...  
Barking...  
Whining...

3. Hierarchical Inheritance

When several classes inherit from a single parent class, this is known as hierarchical inheritance. This enables many child classes to exhibit distinct behavior despite sharing common characteristics.

Code Example:

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

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

class Cat extends Animal {
    void meow() {
        System.out.println("Meowing...");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.eat();  // Inherited from Animal
        dog.bark(); // Specific to Dog

        cat.eat();  // Inherited from Animal
        cat.meow(); // Specific to Cat
    }
}

Output:

Eating...  
Barking...  
Eating...  
Meowing...  

4. Multiple Inheritance with Interfaces

Java does not support multiple inheritance with classes because it can create conflicts when two parent classes have the same method name (this is called the "diamond problem"). However, Java allows multiple inheritance using interfaces.

5. Hybrid Inheritance

Hybrid inheritance combines multiple types of inheritance into a single structure. Since Java does not support direct multiple inheritance with classes, it is usually implemented using interfaces to avoid conflicts.

Java inheritance enables a class to acquire properties and behaviors from another class. Multilevel Inheritance Example in Java: Here's how to use it:

• Use the extends keyword to create a child class from a parent class.
• Override methods in the child class to change behavior.
• Use the super keyword to call the parent class's methods.

Multilevel Inheritance Example in Java

class Vehicle {
    void start() {
        System.out.println("Vehicle is starting...");
    }
}

class Car extends Vehicle {
    void start() {
        super.start(); // Calls the parent class method
        System.out.println("Car engine is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.start();
    }
}

Output:

Vehicle is starting...  
Car engine is running... 

When a Java class inherits from another class that is already a subclass, this is known as multilevel inheritance. As a result, the relationships between grandparents, parents, and children form a chain-like structure.

Example:

class Grandparent {}  
class Parent extends Grandparent {}  
class Child extends Parent {} 

Syntax of Multilevel Inheritance in Java

class A { /* Base class */ }  
class B extends A { /* Inherits from A */ }  
class C extends B { /* Inherits from B */ } 

Example 1: Transportation Evolution

class Cycle {
    void display() { System.out.println("Powered by pedaling"); }
}

class Motorcycle extends Cycle {
    void display() {
        super.display();
        System.out.println("Now with an engine");
    }
}

class E_Bike extends Motorcycle {
    void display() {
        super.display();
        System.out.println("Electric motor added");
    }
}

public class TransportTest {
    public static void main(String[] args) {
        E_Bike bike = new E_Bike();
        bike.display();
    }
}

Output:

Powered by pedaling  
Now with an engine  
Electric motor added 

Code Explanation:

This Java sample demonstrates multilayer inheritance. By incorporating an engine, the Motorcycle class expands on the Cycle class, which stands for basic transportation. Lastly, an electric motor is introduced by E_Bike, which is derived from a motorcycle. This describes a Java multilevel inheritance program in which every subclass builds on the one before it. All inherited methods are executed sequentially when we call show() on an E_Bike object.

Time and Space Complexity:

• Time Complexity: O(1) – Each method runs in constant time.
• Space Complexity: O(1) – No extra memory is used apart from the object itself.

Example 2: Car Manufacturing Hierarchy

class Vehicle {
    void ignite() { System.out.println("Vehicle is on!"); }
}

class Sedan extends Vehicle {
    void brand() { System.out.println("Sedan Brand: Honda"); }
}

class Civic extends Sedan {
    void maxSpeed() { System.out.println("Top Speed: 120km/h"); }
}

public class CarHierarchy {
    public static void main(String[] args) {
        Civic myCar = new Civic();
        myCar.ignite();
        myCar.brand();
        myCar.maxSpeed();
    }
}

Output:

Vehicle is on!  
Sedan Brand: Honda  
Top Speed: 120km/h

Code Explanation:

This Java Multilevel Inheritance Example demonstrates Java multilevel inheritance. Sedan inherits the ignite() function from the Vehicle class, which adds brand(). Sedan is extended by the Civic class, which adds maxSpeed(). This demonstrates a Java multilevel inheritance application in which the creation of a Civic object enables it to call methods from all parent classes in accordance with the hierarchy.

Time and Space Complexity:

• Time Complexity: O(1) (all methods execute in a fixed amount of time).
• Space Complexity: O(1) (Little memory use because no additional data structures are utilized).

Note 

The examples show how multilevel inheritance works in Java by establishing a chain of class relationships. In the "Transportation Evolution" and "Car Manufacturing Hierarchy" scenarios, each subclass increases the capabilities of its parent, allowing features and behaviors to be improved and reused at all levels. This structure not only promotes logical organization and code reuse, but it also mimics real-world hierarchies, making the code easier to comprehend and maintain. Additionally, since each method operates independently and requires no additional memory, time and space complexities remain constant (O(1)), ensuring efficient performance even as the inheritance chain grows.

Realistic real-world analogies and helpful coding examples are the best ways to understand multilevel inheritance. Here are some instances of how Java applications use this concept.

Example 1: Animal Hierarchy

Consider an animal kingdom where each level adds specific characteristics:

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

class Mammal extends Animal {
    void walk() {
        System.out.println("Walking...");
    }
}

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

public class TestInheritance {
    public static void main(String[] args) {
        Dog dog = new Dog();

        dog.eat();   // Inherited from Animal
        dog.walk();  // Inherited from Mammal
        dog.bark();  // Defined in Dog
    }
}

Output:

Eating... 
Walking... 
Barking...

Explanation:
Dog inherits from Mammal, which in turn inherits from Animal. This means Dog has access to both eat() and walk() methods, in addition to its own bark() method. This mirrors real life, where a dog is a mammal and a mammal is an animal.

Example 2: Vehicle Manufacturing Hierarchy

Imagine a vehicle production line where each class adds new features:

class Vehicle {
    void ignite() {
        System.out.println("Vehicle is on!");
    }
}

class Sedan extends Vehicle {
    void brand() {
        System.out.println("Sedan Brand: Honda");
    }
}

class Civic extends Sedan {
    void maxSpeed() {
        System.out.println("Top Speed: 120km/h");
    }
}

public class CarHierarchy {
    public static void main(String[] args) {
        Civic myCar = new Civic();

        myCar.ignite();    // Inherited from Vehicle
        myCar.brand();     // Inherited from Sedan
        myCar.maxSpeed();  // Defined in Civic
    }
}

Output:

Vehicle is on! 
Sedan Brand: Honda 
Top Speed: 120km/h

Explanation:

‍The Civic class inherits features from Sedan, which in turn inherits from Vehicle. This chain allows a Civic object to access all methods up the hierarchy, just as a real-world car model builds on its predecessors.

Example 3: Shipping and Logistics (Business Domain)

A practical business scenario might involve classes for shipping:

class Box {
    double width, height, depth;

    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }

    double volume() {
        return width * height * depth;
    }
}

class BoxWeight extends Box {
    double weight;

    BoxWeight(double w, double h, double d, double m) {
        super(w, h, d);
        weight = m;
    }
}

class Shipment extends BoxWeight {
    double cost;

    Shipment(double w, double h, double d, double m, double c) {
        super(w, h, d, m);
        cost = c;
    }
}

public class TestShipment {
    public static void main(String[] args) {
        Shipment shipment = new Shipment(2, 3, 4, 5, 10.5);

        System.out.println("Volume: " + shipment.volume());
        System.out.println("Weight: " + shipment.weight);
        System.out.println("Cost: " + shipment.cost);
    }
}

Output:

Volume: 24.0 
Weight: 5.0 
Cost: 10.5

Explanation:

‍Each subclass provides more information in this case: Box defines the fundamental shape, BoxWeight adds weight, and Shipment adds cost. This is similar to real-world logistics in that fresh information is added at each stage.

Real-life Analogy: Family Tree

A family hierarchy is a relatable analogy for multilevel inheritance:

• GreatGrandparent → Grandparent → Parent → Child

Each generation inherits traits from the previous one. In Java, this would look like:

class GreatGrandparent {
    /* traits */
}

class Grandparent extends GreatGrandparent {
    /* more traits */
}

class Parent extends Grandparent {
    /* even more traits */
}

class Child extends Parent {
    /* unique traits */
}

Just like in a family, the Child class has access to all properties and behaviors from its ancestors.

Summary

These examples and analogies show how multilevel inheritance allows Java classes to build upon one another, creating a logical and reusable structure. Whether modelling animals, vehicles, business processes, or families, multilevel inheritance enables each subclass to inherit and extend the features of its predecessors, making code more organized, efficient, and reflective of real-world relationships.

A comparison of multilevel inheritance with single, multiple, hierarchical, and hybrid inheritance in Java is listed below:

1. Enterprise Systems

Enterprise applications employ Java's multilevel inheritance to build organized hierarchies. In a user management system, for example, a super admin would have complete power over the system, an admin might have more benefits, and a basic user would have restricted access. Clear role delineation and simple permission management are guaranteed by this structure.

2. Game Development

Java's multilayer inheritance makes it easier to organize many kinds of in-game features. An enemy character can inherit the characteristics and behaviors of a generic game object, for instance, while a boss character can add more powers and skills to the enemy class.

3. UI Frameworks

Multilevel inheritance is used by user interface (UI) frameworks to produce reusable and customized components. Custom widgets can inherit and change common properties defined by a base UI component. This makes it possible for developers to effectively create intricate and dynamic interfaces.

‍

4. Domain Modeling in Banking Systems

Complex financial systems may be simulated with Java's multilevel inheritance. For example, a base Account class can offer general attributes and methods, a SavingsAccount type can enhance Account with the ability to calculate interest, and a PremiumSavingsAccount can further expand SavingsAccount with unique advantages. This hierarchy makes code maintenance easier and makes it easier to install particular account types.

5. Educational Platforms and Course Structures

In educational software, multilevel inheritance helps to organize user roles and course material. For instance, InteractiveVideoLecture may enhance a basic CourseMaterial lecture with quizzes and engagement analytics. Similarly, User might be expanded by Student and then GraduateStudent, signifying further advanced access and capabilities. This framework preserves the scalability and maintainability of the platform.

6. E-Commerce Applications

E-commerce platforms employ multilevel inheritance to manage many user and product categories. For example, a category-specific product may provide additional features, a premium product might have exclusive deals or discounts, and a general product class might describe basic attributes like price and description.

Although multilevel inheritance can facilitate code organization and encourage reuse, developers should be aware of the following dangers and challenges:

1. Increased Complexity and Maintenance Challenges

As the inheritance chain lengthens, it becomes more difficult to understand how action and data pass through several classes. Debugging and code maintenance may take longer as a result, especially if changes to a superclass have an impact on several subclasses.

2. Tight Coupling and Reduced Flexibility

Multilevel inheritance creates a strong bond between subclasses and their superclasses. Any changes made to a superclass may unintentionally affect all derived classes, potentially leading to mistakes or requiring significant modifications. Flexibility may be hindered and future advancement inhibited.

3. Fragile Base Class Problem

Even small modifications to the base class can disrupt functioning in subclasses that significantly rely on the implementation details of their descendants. In deep inheritance hierarchies, this is referred to as the "fragile base class problem," and it poses a serious risk.

4. Difficulty in Refactoring

Refactoring code becomes more difficult when there are several layers of inheritance. Restructuring the hierarchy or transferring fields or methods between classes may have unforeseen consequences across the inheritance chain.

5. Hidden Inherited Members

Subclasses may inherit fields or methods in deep hierarchies that are not immediately apparent to a reader of the code. Unintentional overrides or the use of out-of-date or obsolete functionality may result from this.

6. Diamond Problem and Java’s Solution

Confusion can nevertheless occur when classes in the hierarchy share method names or properties, even though Java does not permit multiple inheritance with classes, avoiding the traditional diamond problem. Developers need to make sure that the class structure is clear and watch out for method overriding.

Best Practices to Avoid Issues

• If at all feasible, keep inheritance structures simple.
• To improve flexibility, prioritize composition over inheritance.
• Clearly record inherited fields and methods.
• To make method overriding explicit and avoid unintentional mistakes, use the @Override annotation.
• Excessive depth and complexity can be avoided by routinely reviewing and reworking class hierarchies.

In Java, a class can inherit from another class that is derived from a parent class with the help of multilevel inheritance. This establishes a chain of inheritance, which facilitates structured code organization and encourages reusability. Through comprehension of multilevel inheritance in Java syntax, useful examples, and suggested coding methods, developers can produce scalable, well-organized applications with minimal redundancy. In object-oriented programming, this method guarantees a logical hierarchy, increases efficiency, and improves code maintainability.

Points to Remember 

1. Each subclass in a chain of classes created by multilevel inheritance inherits methods and attributes from all of its grandparent classes, not just its direct parent.
2. Java limits multiple inheritance with classes to prevent ambiguity and complexity, however it does permit multilevel inheritance using classes.
3. The most specific (child class) implementation is carried out during runtime since method overriding operates from bottom to top.
4. Multilevel inheritance should only be utilized when it accurately represents relationships found in the actual world because deeper inheritance hierarchies increase complexity.
5. When inheritance begins to make the code difficult to comprehend or maintain, utilize composition instead of deep inheritance.

1. What is multilevel inheritance?

When a subclass is descended from another subclass, creating a chain of inheritance, this is known as multilevel inheritance. Multilevel inheritance is created, for instance, when class B inherits from class A and class C inherits from class B.

2. How is multilevel inheritance different from multiple inheritance?

In multilevel inheritance, a class inherits from only one superclass at each level, forming a hierarchy.
In multiple inheritance, a class inherits from more than one superclass at the same time (which is not supported directly in Java but allowed in C++).

3. What are superclasses and subclasses in multilevel inheritance?

• A superclass is a class whose properties and methods are inherited.
• A subclass is a class that inherits properties and methods from a superclass.
  In multilevel inheritance, a class can be both a subclass and a superclass at the same time.

4. Is multilevel inheritance supported in Java?

Yes, Java fully supports multilevel inheritance using classes. However, Java does not support multiple inheritance with classes to avoid ambiguity.

5. Can constructors be inherited in multilevel inheritance?

No, constructors are not inherited. However, constructors of superclasses are called automatically using super() when a subclass object is created.

6. How does method overriding work in multilevel inheritance?

When a subclass overrides a method from its superclass, the most accurate implementation (lowest-level subclass) is invoked at runtime. This supports runtime polymorphism.

7. What types of inheritance exist in OOP?

Common types of inheritance include:

• Single inheritance
• Multilevel inheritance
• Hierarchical inheritance
• Multiple inheritance (language-dependent)
• Hybrid inheritance

8. Does multilevel inheritance support polymorphism?

Yes, multilevel inheritance supports polymorphism, allowing method calls to behave differently based on the object’s runtime type.