What is multilevel inheritance in Java?

In this article, we are going to discuss what is inheritance, the types of inheritance, and finally what multiple inheritance is and how is it different from the other type of inheritance in Java.

What is Inheritance?

Inheritance is the ability of one class to inherit the properties or capabilities of another class.
Now, what exactly is a class? Class is simply a representation or template to build a specific object type. It is a basic concept of Object-Oriented Programming which revolve around real-life entities. In Java, a class determines how an object will behave and what the object will contain. An object is an instance of a class, it is nothing but a self-contained component that consists of methods and properties to make a particular type of data useful. For example- color name, table name, etc.

Say class X has inherited the properties of class Y, then class X is called the child class, derived class, or subclass, and class Y is called the parent class, base class, or superclass. The object of class X can now access the methods and fields of class Y, it can also override them. It is because of the inheritance only that we can reuse our code whenever possible and reduce redundancy. In order to inherit another class, you have to use extends keyword.

You can think of inheritance when a child inherits the traits of his/her parents. It is one of the most important concepts of Object Oriented Programming (OOPs).

Types of Inheritance

We will now discuss the various type of inheritance and which one is supported and not supported in Java. We categorize them on the basis of class.

Single inheritance

The most basic type of Inheritance is single inheritance where one class inherits the properties of another class.
Think of Animal class as an example where Dog class inherits the properties of Animal class. Here, only single inheritance is happening, one class is inheriting from only one another class. Dog class extends Animal class.
Let’s take class B which inherits class A.

class A{  
... ... ...  
}  
class B extends A{  
... ... ... 
}  
Code language: Java (java)

As you can observe, since class B extends class A, the object of class B can now access the methods defined in class A. This is the power of inheritance.

Multiple Inheritance

When you try to inherit from numerous classes, then this is called multiple inheritance. In this case, we can have multiple superclasses.
For example, Bat derives from superclasses- Mammal and Winged Animal.

Derived class has features of Base1 and Base2.
It is not supported in Java.

Why multiple inheritance is not supported in Java?

Multiple Inheritance is supported in C++ but not in Java, why? It’s because Java doesn’t allow ambiguity. But how does multiple inheritance causes ambiguity? Say you have a class C that extends class A and B, and both class A and B have a common method called run(), if the object of class C calls the method run(), then Java compiler will get confused about which method to inherit from which class and this causes ambiguity.

How to achieve Multiple Inheritance in Java?

Fortunately, we have a way to achieve multiple inheritance in Java, via interfaces.

Interface is a blueprint of a class that consists of static constants and abstract methods. An abstract method is a method declared with abstract keyword and does not have any implementation. Only abstract methods are allowed in the Java interface, not the method body. Abstraction and multiple inheritance are achieved through interfaces in Java.

The following code is not allowed in Java –

public class A extends B, C{}
Code language: Java (java)

However, we can make a class extend one or more interfaces, hence helping us in achieving multiple inheritance.

// interface example
interface Ajay {
  public void walk(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}
Code language: Java (java)

Just like in inheritance, when you want to inherit an interface in an interface, you need to use extends keyword. To inherit an interface in a class, you need to use implements keyword.

class extends another class, class implements an interface, and an interface extends another interface.

//interface 1 
interface StudentA
{
	//interfaces method are only declared not defined
	public void walk();
}

//interface 2
interface StudentB
{
	//any number of methods can be declared in the interface
	public void walk();
	public void run();
}

//multiple inheritance achieved
class StudentC implements StudentA,StudentB
{   
	//overidden methods 
	public void walk()
	{
		System.out.println("StudentA is walking ");
	}
    public void run()
    {
    	System.out.println("StudentB is running ");
    }
    public static void main (String args[])
    {
    	StudentC object = new StudentC();
    	object.walk();
    	object.run();
    }
}
Code language: Java (java)

#Output-
StudentA is walking 
StudentB is running 
Code language: Java (java)

We have achieved multiple inheritance via interface. We declared methods in interfaces called StudentA and StudentB. While implementing these interfaces in class StudentC, we have overridden these methods. Overriding means the method declared, is being defined again with the same name, return type, and parameters. As you can observe, we have re-implemented walk() and run() methods in our child class, StudentC. When the object of the child class will call these methods, there will be no ambiguity and we will get our desired output.

Multilevel Inheritance

When you derive from a class that is already deriving from another class, that means, say you have a class C that derives from class B that derives from class A, this scenario is called multilevel inheritance.

class A { 
... .. ... 
};
class B extends A {
... .. ...
};
class C extends B {
... ... ...
};
Code language: Java (java)

For example- Son inherits from his Father who inherits from his own Father (Son’s grandfather), so there becomes three classes, class Son extending class Father and class Father extending class Grandfather.

Hierarchical Inheritance

This type of inheritance occurs when numerous subclasses derive from a single class. All the features common in subclasses are included in the superclass.

class A is inherited by class D, class C, and class B.

class A { 
... .. ... 
};
class B extends A {
... .. ...
};
class C extends A {
... ... ...
};
class D extends A{
... ... ...
};
Code language: Java (java)

For example- Dog, Cat, Horse derive from Animal class.

Hybrid Inheritance

In hybrid inheritance, a combination of single and multiple inheritance is observed, and as we’ve already read, multiple inheritance is not allowed in Java.

class B and class C extends class A, and class D extends both class B and C.

How multilevel inheritance is different from other types in Java?

Multilevel Inheritance is not the same as multiple inheritance, as the former has one derived class inheriting from another derived class and the latter has one or more base classes for one subclass. So, here in multilevel inheritance, we have a derived class acting like a parent to another class.