Thursday, 14 January 2016

Java Tutorial : Multiple Inheritance by Interface(extends)

🔥 Want to Master Java Faster?

Join the Ram N Java community for weekly tutorials that make complex coding concepts simple!

Multiple Inheritance by Interface (extends)

In Java, a class cannot extend more than one class. This is a fundamental rule. However, did you know that an Interface can extend multiple interfaces? Today, we are exploring how Java supports multiple inheritance through the extends keyword in interfaces.

The Power of "Extends" in Interfaces

While classes use the implements keyword to gain behavior from an interface, one interface can inherit from another using extends. Most importantly, an interface is allowed to extend multiple interfaces at the same time.

How It Works: The Syntax

The syntax is straightforward. You simply list the parent interfaces after the extends keyword, separated by commas:

 interface Parent1 { ... }
interface Parent2 { ... }
interface Child extends Parent1, Parent2 { ... } 

Why Does Java Allow This?

Java allows multiple inheritance among interfaces because interfaces do not contain state (variables) or implementation details (method bodies). This removes the "Diamond Problem" conflict found in class-based multiple inheritance. When a class eventually implements the "Child" interface, it simply takes on the responsibility of providing code for all methods inherited from both Parent1 and Parent2.

Quick Summary

Classes: Single inheritance only (one parent class).
Interfaces: Can extend multiple interfaces.
Key Benefit: It allows you to build complex hierarchies and "contracts" without the ambiguity of class conflicts.

Related Tutorials from Ram N Java:

Enhance your Object-Oriented Programming knowledge with these related videos:

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

Click the below Image to Enlarge

Java Tutorial : Multiple Inheritance by Interface(extends)

InterfaceA.java

public interface InterfaceA
{
    void sayHi();       
}

InterfaceB.java

public interface InterfaceB
{
    void sayBye();
}

InterfaceC.java

public interface InterfaceC extends InterfaceA, InterfaceB
{
    void sayWelcome();
}

MyClass.java

public class MyClass implements InterfaceC
{

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

    @Override
    public void sayBye()
    {
        System.out.println("Bye");
    }

    @Override
    public void sayWelcome()
    {
        System.out.println("Welcome");
    }

}

InterfaceTest.java

public class InterfaceTest
{

    public static void main(String[] args)
    {
        InterfaceC interfaceCRef = new MyClass();
        interfaceCRef.sayHi();
        interfaceCRef.sayBye();
        interfaceCRef.sayWelcome();
    }

}

Output