Multiple Inheritance is an object-oriented concept where a class can inherit from more than one parent class. While powerful, it can cause ambiguity when multiple parents have the same methods.
- If two of the parent classes have a method with the same signature, the compiler cannot determine which one to execute.
- This ambiguity is the reason Java does not support multiple inheritance with classes.
Java doesn't support Multiple Inheritance
Java does not support multiple inheritance with classes to avoid ambiguity problems like the Diamond Problem, where a class may inherit the same method from multiple parent classes.
Example 1: Multiple Inheritance with Classes gives Error in Java
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
Achieving Multiple Inheritance with Interfaces
Java allows a class to implement multiple interfaces, to supporting multiple inheritance safely.
interface A{
default void display(){
System.out.println("Interface A display");
}
}
interface B{
default void display(){
System.out.println("Interface B display");
}
}
class C implements A, B{
@Override
public void display(){
// Resolving conflict
A.super.display();
B.super.display();
System.out.println("Class C display");
}
}
public class Main {
public static void main(String[] args){
C obj = new C();
obj.display();
}
}
Output
Interface A display Interface B display Class C display
Explanation:
- Class C implements both interfaces A and B.
- Both interfaces define a default method display(), causing potential conflicts.
- C resolves conflict by explicitly calling A.super.display() and B.super.display().
- Finally, C adds its own logic, achieving multiple inheritance safely.
Example 2: Handling Default Methods (Java 8+)
In Java 8, interfaces can have default methods with implementations. If a class implements multiple interfaces with the same default method, it must override the method or explicitly choose one using InterfaceName.super.method().
// 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
Explanation:
- Both interfaces PI1 and PI2 define default method show().
- TestClass overrides show() to resolve the conflict using super.
- Additional methods showOfPI1() and showOfPI2() call each interface method explicitly.
- Without overriding, the compiler throws an error, default methods in multiple interfaces must be handled explicitly.
Note: Using interfaces with default methods in Java is a way to safely solve the diamond problem, allowing a class to inherit behavior from multiple interfaces without ambiguity.