Why Multiple Inheritance not possible in java?

Expert Posts
,
1

Multiple inheritance is not possible in Java when it comes to classes, meaning a class cannot directly inherit from more than one class. This restriction exists to avoid complexity and ambiguity that can arise from multiple inheritance, especially with the "Diamond Problem."

Understanding the Diamond Problem:

The diamond problem is a well-known issue in multiple inheritance scenarios. It occurs when a class inherits from two classes that both inherit from a common superclass.

Example of the Diamond Problem:

  • Suppose we have three classes: A, B, and C.
  • Class B and class C both inherit from class A.
  • Now, if there is a class D that tries to inherit from both B and C, it creates a diamond shape in the inheritance hierarchy.
      A
     / \
    B   C
     \ /
      D

  • If class A has a method display(), and both B and C inherit this method without overriding it, then class D will inherit the display() method from both B and C. Now, if D tries to call display(), there is ambiguity about which version of the method to use: the one from B or the one from C.

This ambiguity makes it difficult for the compiler and the developer to predict which method should be invoked, leading to potential errors and unexpected behavior.

Java's Solution to the Diamond Problem:

Java avoids the diamond problem by not allowing multiple inheritance with classes. Instead, Java supports multiple inheritance through interfaces, which do not have the same issues because interfaces only provide method declarations (without implementation).

Multiple Inheritance via Interfaces:

  • In Java, a class can implement multiple interfaces, thereby achieving a form of multiple inheritance.
  • Since interfaces don't contain method implementations (until Java 8, where default methods were introduced, but even then, the rules are clear), there is no ambiguity or conflict like the diamond problem.

Example with Interfaces:

interface A {
    void display();
}
interface B {  

void show();


}


class C implements A, B {


@Override


public void display() {


System.out.println("Display method from interface A");


}

@Override
public void show() {
System.out.println("Show method from interface B");
}


}

public class Main {


public static void main(String args) {


C obj = new C();


obj.display(); // Calls display from A


obj.show();    // Calls show from B


}


}