Java Multiple Inheritance

Last Updated : 26 Dec, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

Multiple Inheritance is a feature of an object-oriented concept, where a class can inherit properties of more than one parent class. The problem occurs when there exist methods with the same signature in both the superclasses and subclass. On calling the method, the compiler cannot determine which class method to be called and even on calling which class method gets the priority. 

Note: Java doesn't support Multiple Inheritance

Example 1:

Java 
// Java Doesn't support Multiple Inheritance
import java.io.*;

// First Parent Class 
class Parent1 {
    void fun() { System.out.println("Parent1"); }
}

// Second Parent Class
class Parent2 {
    void fun() { System.out.println("Parent2"); }
}

// Inheriting Properties of
// Parent1 and Parent2
class Test extends Parent1, Parent2 
{
  	// main method
    public static void main(String args[])
    {
      	// Creating instance of Test
        Test t = new Test();

        t.fun();
    }
}

Output: Compilation error is thrown

Conclusion: As depicted from code above, on calling the method fun() using Test object will cause complications such as whether to call Parent1’s fun() or Parent2’s fun() method. 

Example 2: Java Diamond Problem Similar Scenario

          GrandParent
           /     \
          /       \
      Parent1      Parent2
          \       /
           \     /
             Test
Java 
// Java Diamond Problem Similar Scenario

import java.io.*;

// GrandParent Class
class GrandParent {
    void fun() {
       System.out.println("Grandparent"); 
    }
}

// Inheriting GrandParent
class Parent1 extends GrandParent {
    void fun() { 
       System.out.println("Parent1"); 
    }
}

// Inheriting GrandParent
class Parent2 extends GrandParent {
    void fun() {
       System.out.println("Parent2"); 
    }
}

// Child Class inheriting Parent1 and Parent2
class Child extends Parent1, Parent2 
{
	// main method  
    public static void main(String args[])
    {
        Child t = new Child();
        t.fun();
    }
}

Output: 

When you run the fun() method in the Test class, it throws a compiler error due to multiple inheritance, which causes the diamond problem (common in languages like C++). In this case, the code doesn't know whether to call Parent1's or Parent2's fun() method, leading to ambiguity. To avoid such complications, Java does not support multiple inheritance with classes.

Java avoids multiple inheritance with classes because it can lead to complex issues, such as problems with casting, constructor chaining, and other operations. Moreover, multiple inheritance is rarely needed, so Java excludes it to maintain simplicity and clarity in code.

Using Default Methods and Interfaces for Multiple Inheritance

Java 8 supports default methods where interfaces can provide a default implementation of methods. And a class can implement two or more interfaces. In case both the implemented interfaces contain default methods with the same method signature, the implementing class should explicitly specify which default method is to be used in some method excluding the main() of implementing class using super keyword, or it should override the default method in the implementing class, or it should specify which default method is to be used in the default overridden method of the implementing class.

Example 1: Demonstrating Multiple Inheritance through default methods

Java 
// Interface 1
interface PI1 {
    default void show(){
       System.out.println("Default PI1");
    }
}

// Interface 2
interface PI2 {
    default void show(){
      	System.out.println("Default PI2");
    }
}


class TestClass implements PI1, PI2 {

    // Overriding default show method
    @Override
    public void show(){
       PI1.super.show();
       PI2.super.show();
    }
  
  	// Declared new Method
    public void showOfPI1() {
       PI1.super.show(); 
    }
  
  	// Declared new Method
    public void showOfPI2() {
        PI2.super.show(); 
    }

  	// main Method
    public static void main(String args[]) {
        
      	// Instance of Class
      	TestClass d = new TestClass();
        
      	// Using show Method
      	d.show();
        
      	// Executing the Methods
      	System.out.println("Now Executing showOfPI1()" +
                           " showOfPI2()");
        d.showOfPI1();
        d.showOfPI2();
    }
}

Output
Default PI1
Default PI2
Now Executing showOfPI1() showOfPI2()
Default PI1
Default PI2

Note: If we remove the implementation of default method from "TestClass", we get a compiler error. If there is a diamond through interfaces, then there is no issue if none of the middle interfaces provide implementation of root interface. If they provide implementation, then implementation can be accessed as above using super keyword.

Example 2:

Java 
// Java program to demonstrate How Diamond Problem
// Is Handled in case of Default Methods

// Interface 1
interface GPI {

    // Default method
    default void show()
    {

        // Print statement
        System.out.println("Default GPI");
    }
}

// Interface 2
// Extending the above interface
interface PI1 extends GPI {
}

// Interface 3
// Extending the above interface
interface PI2 extends GPI {
}

// Main class
// Implementation class code
class TestClass implements PI1, PI2 {

    // Main driver method
    public static void main(String args[])
    {

        // Creating object of this class
        // in main() method
        TestClass d = new TestClass();

        // Now calling the function defined in interface 1
        // from whom Interface 2and 3 are deriving
        d.show();
    }
}

Output
Default GPI

Next Article
Comparison of Inheritance in C++ and Java
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads