Types of Inheritance in Java: Examples and Tips

Quick Overview:

• Java inheritance lets child classes reuse fields and methods from a parent class, reducing repeated code and keeping class structures organised.
• The main types of Inheritance in Java are single, multilevel, hierarchical, multiple, and hybrid inheritance, with multiple and hybrid inheritance achieved through interfaces.
• You can compare inheritance types based on their class structure, code reuse, complexity, and suitable use cases.
• In this blog, you’ll learn about Java inheritance, its types, examples, comparisons, implementation, advantages, and limitations.

Explore upGrad’s Best Data Science Courses to build skills in Python, data analysis, machine learning, and AI for practical technology projects.

Types of Inheritance in Java With Examples

Inheritance in Java is a key concept that helps classes share fields and methods in a structured way, but different use cases demand different approaches. That’s why there are different types of inheritance in Java to choose from. 

Some tasks only need a simple parent-child structure, while others benefit from a chain of classes that build on one another. Selecting the right inheritance type reduces repetitive code and keeps your applications more straightforward to manage. 

Here’s a quick snapshot table that explains different types of inheritance in Java at a glance.

Check out upGrad’s free tutorial, The Root Class From Which All Java Classes Got Inherited. 

Let’s now take a look at each type in detail and see how it works through examples.

1. Single Inheritance in Java​

Single inheritance in Java involves a single parent class (also known as a superclass) and a single child class (subclass). By extending one class from another, you reuse methods and fields instead of writing them all over again. This keeps the code cleaner and easier to update. 

For instance, if you have a class called Fruit holding general attributes like color and taste, a class called Apple can extend Fruit, automatically receiving these attributes. Changes made in the parent class carry over to the child, minimizing maintenance. 

Single inheritance fits situations where you have a direct “is-a” relationship, and no extra layers of specialization are needed.

Single Inheritance in Java with Example

Below is a short code snippet that demonstrates how the Apple class inherits a color field and showColor() method from Fruit, while adding its own method:

class Fruit {
    String color = "Red";

    void showColor() {
        System.out.println("Fruit color: " + color);
    }
}

class Apple extends Fruit {
    void appleTaste() {
        System.out.println("Apple is sweet.");
    }
}

public class Main {
    public static void main(String[] args) {
        Apple myApple = new Apple();
        myApple.showColor();    // Inherited method from Fruit
        myApple.appleTaste();   // Unique method in Apple
    }
}

Output: 
Fruit color: Red
Apple is sweet.

2. Multilevel Inheritance in Java

Multilevel inheritance in Java places one class beneath another in a straight lineage. A child class inherits from a parent, and then another class can inherit from that child, passing along all previously acquired attributes and methods. This structure is helpful when you need to extend a class step by step because each subclass can build on what was defined before it. 

For instance, a Person class might be extended into an Employee class, which then becomes a Manager class. Changes in the topmost parent automatically carry through each level, reducing the amount of code you need to update. It’s especially useful for scenarios where every new class becomes a more specialized version of its parent.

Multilevel Inheritance in Java with Example

Below, a Base class represents a simple Person, which is extended by Employee, and then further extended by Manager. Notice how Manager has access to both Person and Employee features:

class Person {
    String name = "Rahul";

    void showName() {
        System.out.println("Name: " + name);
    }
}

class Employee extends Person {
    int employeeId = 101;

    void showEmployeeId() {
        System.out.println("Employee ID: " + employeeId);
    }
}

class Manager extends Employee {
    String department = "Sales";

    void showDepartment() {
        System.out.println("Department: " + department);
    }
}

public class Main {
    public static void main(String[] args) {
        Manager mgr = new Manager();
        mgr.showName();         // Inherited from Person
        mgr.showEmployeeId();   // Inherited from Employee
        mgr.showDepartment();   // Unique to Manager
    }
}

Output:
Name: Rahul
Employee ID: 101
Department: Sales

3. Hierarchical Inheritance in Java

Hierarchical inheritance happens when a single parent class has multiple child classes. Each child class inherits shared methods or fields from the parent but keeps its own unique features. 

For instance, a generic Vehicle class might hold data like brand and speed, while two subclasses, Car and Bike, each have specialized methods. This setup helps you store common functionality in one place and still allow each child to grow in its own direction. It keeps the code organized, especially if the parent class encapsulates behavior that applies to every child.

Hierarchical Inheritance in Java with Example

Below, the Instrument class serves as a parent, and both Guitar and Piano inherit its showType() method:

class Instrument {
    String type = "String Instrument";

    void showType() {
        System.out.println("Instrument type: " + type);
    }
}

class Guitar extends Instrument {
    void playGuitar() {
        System.out.println("Playing guitar chords.");
    }
}

class Piano extends Instrument {
    void playPiano() {
        System.out.println("Playing piano keys.");
    }
}

public class Main {
    public static void main(String[] args) {
        Guitar gtr = new Guitar();
        gtr.showType();     // Inherited from Instrument
        gtr.playGuitar();   // Unique to Guitar

        Piano pno = new Piano();
        pno.showType();     // Inherited from Instrument
        pno.playPiano();    // Unique to Piano
    }
}

Output:
Instrument type: String Instrument
Playing guitar chords.
Instrument type: String Instrument
Playing piano keys.

4. Multiple Inheritance in Java

Multiple inheritance occurs when one class tries to inherit features from more than one parent class. Java does not allow this directly through classes because it can lead to confusion when two parent classes have methods with the same name. However, you can achieve a similar effect with interfaces. 

Each interface can declare methods, and a single class can then implement multiple interfaces. This approach lets you blend functionalities without copying code in multiple places.

Multiple Inheritance in Java with Example

In this example, a Robot class implements two interfaces, Worker and Helper, combining their methods:

interface Worker {
    void doWork();
}

interface Helper {
    void provideHelp();
}

class Robot implements Worker, Helper {
    public void doWork() {
        System.out.println("Robot is working.");
    }

    public void provideHelp() {
        System.out.println("Robot is helping.");
    }
}

public class Main {
    public static void main(String[] args) {
        Robot bot = new Robot();
        bot.doWork();       // From Worker interface
        bot.provideHelp();  // From Helper interface
    }
}

Output:
Robot is working.
Robot is helping.

5. Hybrid Inheritance in Java

Hybrid inheritance combines more than one type of inheritance in a single design. While Java does not allow multiple class-based inheritance, you can still create hybrid models through interfaces and class hierarchies. 

For instance, you can have a parent-child structure using classes, then implement multiple interfaces in one or more subclasses. This gives you the benefits of different inheritance types without the conflicts that come from directly extending multiple parent classes. It’s especially useful in larger programs that need both a clear class chain and modular functionalities from various interfaces.

Hybrid Inheritance in Java with Example

Here, in hybrid inheritance in Java, the Base class acts as a parent, two subclasses inherit from it, and one of them implements an extra interface:

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

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

interface Pet {
    void showAffection();
}

class PetDog extends Dog implements Pet {
    public void showAffection() {
        System.out.println("Pet dog shows affection.");
    }
}

public class Main {
    public static void main(String[] args) {
        PetDog myDog = new PetDog();
        myDog.eat();            // Inherited from Animal
        myDog.bark();           // Inherited from Dog
        myDog.showAffection();  // From Pet interface
    }
}

Output:
Animal eats.
Dog barks.
Pet dog shows affection.

What Is Inheritance in Java? 

Inheritance in Java is a principle that allows a new class to borrow attributes and methods from an existing class. It gives you the option to create specialized versions of a broad concept without starting from zero.

Let’s define inheritance in Java with a simple example for better understanding.

• Suppose you have a Teacher class that stores information such as name and subject. 
• A MathTeacher class can extend Teacher, meaning it automatically has those core attributes and any unique qualities you decide to add.
• This setup cuts down on repetitive code and keeps your program flexible.

Now that you’ve seen how it works, let’s go over a few core terms related to Java inheritance.

How Inheritance Works in Java

Inheritance in Java allows one class to acquire the properties and methods of another class. The existing class is called the parent or superclass, while the new class is called the child or subclass.

Java uses the extends keyword to create inheritance between classes.

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

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

Here, Dog inherits the eat() method from Animal while also having its own bark() method.

How Java Inheritance Works

The basic flow is:

1. Create a parent class with common properties or methods.
2. Create a child class using the extends keyword.
3. The child class gets access to the accessible members of the parent class.
4. The child class can add its own methods and properties.
5. It can also override inherited methods to provide different behaviour.

For example:

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

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car starts with a key");
    }
}

Here, Car inherits from Vehicle but overrides the start() method.

Java does not support multiple inheritance through classes, where one class directly extends two classes. It supports multiple inheritance of type through interfaces.

Understanding the inheritance and types of inheritance in Java helps you choose the right class structure and reuse common code across related classes.

Purpose and Necessity of Inheritance in Java

Many Java programs involve classes that share similar data or actions. Without inheritance, you’d end up duplicating these elements in every class, which can lead to confusion and mistakes. Inheritance keeps these shared parts in a single parent class, letting child classes automatically reuse them. 

This setup makes it simpler to update or refine common features, since changes in the parent class apply across all children. It also keeps class design more organized, as you can separate general traits from those that are more specialized.

So, what makes inheritance essential in your code? Let’s explore:

• Reduced Duplication: Shared logic goes into the parent class, so you avoid writing the same methods in different classes.
• Clear Boundaries: It distinguishes between broad behaviors (in the parent) and specific ones (in the child), reducing clutter.
• Extended Flexibility: Subclasses build on top of existing capabilities, speeding up new feature development.

Comparison of Inheritance Types in Java

The main types of inheritance in Java differ in how parent and child classes are connected. Comparing them helps you understand when to use single, multilevel, or hierarchical inheritance.

Single vs Multilevel Inheritance

Single inheritance has one parent class and one child class. Multilevel inheritance extends this structure across multiple levels, where a child class becomes the parent of another class.

Example:

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

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

This is single inheritance because Dog directly inherits from Animal.

For multilevel inheritance:

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

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

class Puppy extends Dog {
    void play() {
        System.out.println("Playing");
    }
}

Here, Puppy inherits from Dog, while Dog inherits from Animal.

Multilevel vs Hierarchical Inheritance

Both are included when learning inheritance and types of inheritance in Java, but their class structures are different.

Hierarchical inheritance 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");
    }
}

Here, both Dog and Cat inherit from Animal.

Single vs Hierarchical Inheritance

Single inheritance connects one parent with one child, while hierarchical inheritance allows multiple child classes to inherit from the same parent.

For types of inheritance in Java with example, a simple comparison is:

• Single: Vehicle → Car
• Multilevel: Vehicle → Car → SportsCar
• Hierarchical: Vehicle → Car and Vehicle → Bike

If you are asking how many types of inheritance in Java, remember that Java supports single, multilevel, and hierarchical inheritance through classes. Multiple inheritance is not supported through classes, but Java can achieve it through interfaces.

How to Implement Inheritance in Java?

Building an inheritance program in Java begins with a parent class with fields and methods you plan to share. Each child class then extends this parent, acquiring those shared elements automatically. 

You can override the parent's methods when you want the child class to behave differently. You can also call the parent’s constructor with super() in the child’s constructor, ensuring that any initial setup in the parent is carried out correctly.

Here’s a simple step-by-step approach:

• Identify Common Traits: Place fields and methods that apply to multiple classes in a single parent class.
• Create the Parent Class: Use class definitions like class Parent { ... } to store shared details.
• Extend for the Child Class: Write class Child extends Parent to inherit all of the parent’s fields and methods.
• Override If Needed: Use the same method signature along with the @Override annotation to customize parent methods in the child class.
• Use super() Wisely: If the parent has a constructor, call it from the child’s constructor to ensure proper initialization.
• Test Your Setup: In the main method, create child class objects and confirm that they access both inherited features and any customized behaviors.

Below is a short example that puts these steps into practice. 

There’s a parent class that sets a name and provides a greet method. The child class extends it, calls the parent’s constructor with super, overrides the greet method, and adds its own method.

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    void greet() {
        System.out.println("Hello, my name is " + name);
    }
}

class Teacher extends Person {
    String subject;

    Teacher(String name, String subject) {
        super(name);  // Calls Person's constructor
        this.subject = subject;
    }

    @Override
    void greet() {
        System.out.println("Hello, I am " + name + ", and I teach " + subject);
    }

    void teach() {
        System.out.println("Teaching now!");
    }
}

public class Main {
    public static void main(String[] args) {
        Teacher t = new Teacher("Priya", "Mathematics");
        t.greet();   // Overridden method
        t.teach();   // Unique method in Teacher
    }
}

Output: 
Hello, I am Priya, and I teach Mathematics
Teaching now!

Advantages and Limitations of Different Types of Inheritance in Java

Each inheritance type in Java offers different benefits and limitations depending on the class structure, code reuse needs, and level of complexity.

Advantages of Inheritance in Java

Here are some key advantages that come from using different types of inheritance in Java:

• Streamlined Reusability: Shared attributes and methods stay in one place, so every subclass automatically benefits.
• Smooth Method Overriding: Subclasses can refine parent methods to match specific needs, allowing flexible behavior without altering the original code.
• Better Abstraction: You can reveal only the necessary parts of a parent class, reducing clutter for child classes.
• Polymorphism Possibilities: Objects of various child classes can be treated as instances of a single parent, opening the door to more dynamic designs.
• Easier Maintenance: Fixes or improvements in the parent class ripple down to all children, keeping everything consistent without extra effort.

Also Read: Polymorphism In OOPS: What is Polymorphism [Detailed Explanation]

Limitations of Inheritance in Java

Although inheritance reduces code repetition, it can also introduce hidden complexity if not planned carefully. A deeply nested chain of classes might confuse anyone new to your codebase. Modifying a single parent class might also have unintended effects on multiple child classes at once. 

Below are some drawbacks to watch out for when using inheritance in Java:

• Tight Coupling: Child classes rely heavily on the parent, so changing the parent class can break existing child implementations.
• Complex Debugging: A long inheritance chain forces you to trace through many layers, making bug fixes more time-consuming.
• Limited Flexibility: Extending multiple classes is not possible directly, and relying too heavily on a single hierarchy can restrict your design.
• Performance Concerns: Deep levels of inheritance may lead to extra overhead, though it’s not usually a deal-breaker for smaller projects.
• Overriding Pitfalls: Overriding methods without fully understanding the parent’s code can cause inconsistent behavior.

Advanced Tips to Master Java Inheritance

Now that you’ve seen where different types of inheritance in Java can go wrong, it’s time to focus on ways to avoid those pitfalls. Proper planning and a clear understanding of inheritance can keep your code efficient, maintainable, and free from surprises. 

Below are a few suggestions that go beyond the basics:

• Keep Class Chains Short: Deep hierarchies can get confusing. Stop yourself from nesting multiple layers unless you truly need them.
• Combine with Composition: If two classes don’t share a genuine parent-child link, embedding one inside the other often works better than forcing inheritance. This preserves code clarity.
• Apply the Liskov Substitution Principle: A child class should be fully capable of standing in for its parent without breaking the expected behavior. If your subclass can’t safely replace the parent, it’s a sign the design needs rethinking.
• Document Method Overrides: Briefly note why you’re overriding a parent method and how the behavior differs. This helps future debugging and team collaboration.
• Use final Wisely: Mark classes or methods as final to prevent further extension or overriding where you need strict control over the code’s behavior.
• Test in Layers: Each class in the chain deserves its own test coverage. This reveals potential conflicts right at the level where they occur.

You can also explore upGrad’s free tutorial on Final Class in Java. Understand the methods and advantages, and learn how to create final classes with ease.

How Can upGrad Help You Learn Inheritance in Java?

Learning inheritance and the types of inheritance in Java open doors to advanced development skills and career opportunities. upGrad offers comprehensive learning programs to ensure you gain theoretical knowledge and hands-on experience.

If you’re ready to dive deeper into Java programming, here are some curated programs offered by upGrad:

• JavaScript Basics from Scratch
• Java Object-oriented Programming
• Advanced JavaScript for All
• Data Structures & Algorithms

Don’t let the complexities of inheritance hold you back. With upGrad’s expert guidance, you can confidently figure out your interests and the right path. Book your career counseling session today and find the perfect course for your goals!

Related Blogs:

• What is Composition in Java With Examples
• Polymorphism vs. Inheritance: Difference Between Polymorphism & Inheritance
• Abstract Class and Methods in Java: Key Concepts, Examples and Best Practices

Reference Link:
https://www.statista.com/statistics/793628/worldwide-developer-survey-most-used-languages/