Thursday, 14 January 2016

Java Tutorial : Why Multiple Inheritance is supported using Interface?

🌟 Master Java Programming with Us!

Enjoying these breakdowns? Join thousands of developers on our journey to coding excellence!

Multiple Inheritance in Java: Why Interfaces are the Answer

A common question for Java beginners is why the language prohibits multiple inheritance with classes but allows it with interfaces. Today, we're clearing up that confusion with a simple, clear explanation.

The Problem: The Diamond Problem

If Java allowed a class to extend two parent classes, and both parents had a method with the same name (like display()), the child class wouldn't know which version to use. This ambiguity is known as the Diamond Problem. To keep things simple and safe, Java prevents this for classes.

How Interfaces Save the Day

Interfaces are different. They contain method signatures but (traditionally) no implementation. Here is why they work for multiple inheritance:

No Ambiguity: Since the interface doesn't provide the logic (the code inside the method), the implementing class must provide its own implementation.
Clear Responsibility: The compiler doesn't get confused because it knows the child class will define exactly how the method should behave.
Flexibility: A class can implement as many interfaces as it needs, allowing it to take on multiple "behaviors" without the messy side effects of class inheritance.

Key Summary for Beginners

Classes: Only one parent allowed (to avoid conflict).
Interfaces: Multiple allowed (because the child defines the logic).
Rule of Thumb: Use interfaces when you want to define a "contract" that multiple classes can follow in their own unique ways.

Explore More Java Concepts:

Check out these other videos from Ram N Java to strengthen your OOP skills:

Click here to watch in Youtube :
https://www.youtube.com/watch?v=tqi2-q6oplM&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

Java Tutorial : Why Multiple Inheritance is supported using Interface?

InterfaceA.java

public interface InterfaceA
{
    void sayHi();       
}

InterfaceB.java

public interface InterfaceB
{
    void sayHi();
}

MyClass.java

public class MyClass implements InterfaceA,InterfaceB
{

    @Override
    public void sayHi()
    {
        System.out.println("Hi by MyClass");
    }

}

InterfaceTest.java

public class InterfaceTest
{

    public static void main(String[] args)
    {
        MyClass myClassObj = new MyClass();
        myClassObj.sayHi();

    }

}

Output