Multiple Inheritance Using Interface

Java does not support multiple inheritance using classes, but it fully supports multiple inheritance using interfaces. This allows a class to inherit multiple behaviors without the ambiguity problems that occur with class-based multiple inheritance. This is a very high-frequency interview topic.

What Is Multiple Inheritance?

Multiple inheritance means a class inherits from more than one parent.

Child  →  Parent1
       →  Parent2
          

❌ Java does not allow this with classes
✔ Java allows this using interfaces

Why Java Disallows Multiple Inheritance with Classes

Diamond Problem (Ambiguity)

class A {
    void show() { }
}
class B extends A {
    void show() { }
}
class C extends A {
    void show() { }
}
// class D extends B, C { } // ❌ Ambiguous
          

❓ Which show() should D inherit — from B or C?

👉 To avoid this ambiguity, Java prohibits multiple inheritance with classes.

How Interfaces Solve the Problem

• Interfaces do not carry state (no instance variables)
• Methods are abstract by default
• Implementing class provides the implementation
• No ambiguity in behavior resolution

Basic Syntax: Multiple Inheritance Using Interfaces

interface A {
    void show();
}
interface B {
    void display();
}
class C implements A, B {
    public void show() {
        System.out.println("Show from A");
    }
    public void display() {
        System.out.println("Display from B");
    }
}
          

✔ One class
✔ Multiple interfaces
✔ No ambiguity

Key Rules (Interview Favorites)

1. A class can implement multiple interfaces

class Test implements A, B, C { }
          

2. A class must implement all interface methods

• Otherwise, the class must be declared abstract

3. Interfaces use implements, not extends (for classes)
4. Interfaces can extend multiple interfaces

interface C extends A, B { }
          

Multiple Inheritance with Method Name Conflict (Java 7 and Below)

interface A {
    void show();
}
interface B {
    void show();
}
class C implements A, B {
    public void show() {
        System.out.println("Single implementation resolves conflict");
    }
}
          

✔ No ambiguity
✔ One implementation satisfies both interfaces

Java 8+ Default Method Conflict (Important)

Problem

interface A {
    default void show() {
        System.out.println("A");
    }
}
interface B {
    default void show() {
        System.out.println("B");
    }
}
class C implements A, B {
    // ❌ Compile-time error
}
          

❌ Ambiguous default methods

Solution: Override the Method

class C implements A, B {
    @Override
    public void show() {
        A.super.show(); // or B.super.show()
    }
}
          

✔ Explicit conflict resolution
✔ Fully controlled behavior

Interface vs Class in Multiple Inheritance

Real-World Example (Interview-Friendly)

interface Camera {
    void takePhoto();
}
interface GPS {
    void navigate();
}
class SmartPhone implements Camera, GPS {
    public void takePhoto() {
        System.out.println("Taking photo");
    }
    public void navigate() {
        System.out.println("Navigating");
    }
}
          

✔ One device
✔ Multiple capabilities
✔ Clean design

Why Multiple Inheritance via Interface Is Powerful

• Supports loose coupling
• Enables plug-and-play behavior
• Avoids ambiguity
• Forms the backbone of Java frameworks

Examples:

• JDBC (Connection, Statement)
• Collections (List, Set, Map)
• Spring interfaces

Multiple Inheritance Using Interfaces: 20 Quick Examples

1. Basic Multiple Inheritance Using Interfaces

interface A {
    void a();
}

interface B {
    void b();
}

class C implements A, B {
    public void a() {
        System.out.println("Method A");
    }

    public void b() {
        System.out.println("Method B");
    }

    public static void main(String[] args) {
        C c = new C();
        c.a();
        c.b();
    }
}
          

Output

Method A
Method B
          

2. Multiple Interfaces with Common Method Name

interface A {
    void show();
}

interface B {
    void show();
}

class C implements A, B {
    public void show() {
        System.out.println("Single implementation");
    }

    public static void main(String[] args) {
        new C().show();
    }
}
          

Explanation: One implementation satisfies both interfaces.

Output: Single implementation

3. Diamond Problem Solved with Interfaces (Abstract Methods)

interface A {
    void show();
}

interface B extends A {}

interface C extends A {}

class D implements B, C {
    public void show() {
        System.out.println("Resolved");
    }

    public static void main(String[] args) {
        new D().show();
    }
}
          

Explanation: No ambiguity because method is abstract.

Output: Resolved

4. Diamond Problem with Default Methods (Conflict)

interface A {
    default void show() {
        System.out.println("A");
    }
}

interface B {
    default void show() {
        System.out.println("B");
    }
}

class C implements A, B {
    public void show() {
        System.out.println("C");
    }

    public static void main(String[] args) {
        new C().show();
    }
}
          

Explanation: Class must override conflicting default method.

Output: C

5. Calling Specific Interface Default Method

interface A {
    default void show() {
        System.out.println("A");
    }
}

interface B {
    default void show() {
        System.out.println("B");
    }
}

class C implements A, B {
    public void show() {
        A.super.show();
    }

    public static void main(String[] args) {
        new C().show();
    }
}
          

Explanation: Explicitly chooses interface implementation.

Output: A

6. Multiple Interfaces + Class Inheritance

interface Fly {
    void fly();
}

interface Swim {
    void swim();
}

class Animal {
    void eat() {
        System.out.println("Eating");
    }
}

class Duck extends Animal implements Fly, Swim {
    public void fly() {
        System.out.println("Flying");
    }

    public void swim() {
        System.out.println("Swimming");
    }

    public static void main(String[] args) {
        Duck d = new Duck();
        d.eat();
        d.fly();
        d.swim();
    }
}
          

Output

Eating
Flying
Swimming
          

7. Interface Extending Multiple Interfaces

interface A {
    void a();
}

interface B {
    void b();
}

interface C extends A, B {
    void c();
}

class D implements C {
    public void a() { System.out.println("A"); }
    public void b() { System.out.println("B"); }
    public void c() { System.out.println("C"); }

    public static void main(String[] args) {
        C obj = new D();
        obj.a();
        obj.b();
        obj.c();
    }
}
          

Output

A
B
C
          

8. Multiple Inheritance via Interface Reference

interface A {
    void a();
}

interface B {
    void b();
}

class C implements A, B {
    public void a() { System.out.println("A"); }
    public void b() { System.out.println("B"); }

    public static void main(String[] args) {
        A a = new C();
        B b = new C();
        a.a();
        b.b();
    }
}
          

Explanation: Same object, different views.

Output

A
B
          

9. Interface Constants in Multiple Inheritance

interface A {
    int X = 10;
}

interface B {
    int Y = 20;
}

class C implements A, B {
    public static void main(String[] args) {
        System.out.println(X + Y);
    }
}
          

Explanation: Interface variables are public static final.

Output: 30

10. Multiple Interfaces with No Conflict

interface Print {
    void print();
}

interface Scan {
    void scan();
}

class PrinterScanner implements Print, Scan {
    public void print() {
        System.out.println("Printing");
    }

    public void scan() {
        System.out.println("Scanning");
    }

    public static void main(String[] args) {
        PrinterScanner ps = new PrinterScanner();
        ps.print();
        ps.scan();
    }
}
          

Output

Printing
Scanning
          

11. Interface Default + Abstract Combination

interface A {
    default void show() {
        System.out.println("Default A");
    }
}

interface B {
    void show();
}

class C implements A, B {
    public void show() {
        System.out.println("Implemented");
    }

    public static void main(String[] args) {
        new C().show();
    }
}
          

Explanation: Abstract method forces implementation.

Output: Implemented

12. Functional Interfaces in Multiple Inheritance (Not Allowed)

@FunctionalInterface
interface A {
    void show();
}

// @FunctionalInterface
// interface B {
//     void test();
// }

interface C extends A {
    void test(); // breaks functional rule
}
          

Explanation: Functional interface must have exactly one abstract method.

13. Multiple Inheritance for Capability Modeling

interface Readable {
    void read();
}

interface Writable {
    void write();
}

class FileHandler implements Readable, Writable {
    public void read() {
        System.out.println("Reading file");
    }

    public void write() {
        System.out.println("Writing file");
    }

    public static void main(String[] args) {
        FileHandler f = new FileHandler();
        f.read();
        f.write();
    }
}
          

Output

Reading file
Writing file
          

14. Interface + Default + Override

interface A {
    default void show() {
        System.out.println("A default");
    }
}

interface B {
    default void show() {
        System.out.println("B default");
    }
}

class C implements A, B {
    public void show() {
        B.super.show();
    }

    public static void main(String[] args) {
        new C().show();
    }
}
          

Output

B default
          

15. Real-World Example (Selenium-Style)

interface Clickable {
    void click();
}

interface Typeable {
    void type(String text);
}

class WebElement implements Clickable, Typeable {
    public void click() {
        System.out.println("Clicked");
    }

    public void type(String text) {
        System.out.println("Typed: " + text);
    }

    public static void main(String[] args) {
        WebElement e = new WebElement();
        e.click();
        e.type("Hello");
    }
}
          

Output

Clicked
Typed: Hello
          

16. Multiple Inheritance Prevents Code Duplication

interface Loggable {
    default void log() {
        System.out.println("Logging");
    }
}

interface Trackable {
    default void track() {
        System.out.println("Tracking");
    }
}

class Service implements Loggable, Trackable {
    public static void main(String[] args) {
        Service s = new Service();
        s.log();
        s.track();
    }
}
          

Output

Logging
Tracking
          

17. Interface Reference Hiding Implementation Details

interface A {
    void show();
}

interface B {
    void test();
}

class C implements A, B {
    public void show() { System.out.println("Show"); }
    public void test() { System.out.println("Test"); }

    public static void main(String[] args) {
        A a = new C();
        a.show();
        // a.test(); // not accessible
    }
}
          

Explanation: Reference type controls accessible methods.

18. Multiple Inheritance vs Class Inheritance (Contrast)

class A {}
class B {}

// class C extends A, B {} // ❌ not allowed

interface X {}
interface Y {}

class Z implements X, Y {} // ✔ allowed
          

Explanation: Java allows multiple inheritance only via interfaces.

19. Interview Trap – Same Default Method Signature

interface A {
    default void run() {}
}

interface B {
    default void run() {}
}

class C implements A, B {
    // must override run()
    public void run() {}
}
          

Explanation: Mandatory override due to ambiguity.

20. Interview Summary – Multiple Inheritance Using Interface

interface A {
    void a();
}

interface B {
    void b();
}

class C implements A, B {
    public void a() { System.out.println("A"); }
    public void b() { System.out.println("B"); }

    public static void main(String[] args) {
        A a = new C();
        B b = new C();
        a.a();
        b.b();
    }
}
          

Key Points

• Achieved using implements
• Supports multiple inheritance safely
• Resolves diamond problem
• Promotes loose coupling & polymorphism

Common Beginner Mistakes

• Trying to extend multiple classes
• Forgetting to implement all interface methods
• Confusing extends vs implements
• Ignoring default method conflicts
• Overusing interfaces without need

Interview-Ready Answers

Short Answer

Java supports multiple inheritance using interfaces, not classes.

Detailed Answer

Java avoids multiple inheritance with classes to prevent ambiguity (diamond problem). However, it supports multiple inheritance using interfaces, where a class can implement multiple interfaces and provide its own implementation, ensuring clarity and flexibility.

Key Takeaway

Java achieves multiple inheritance safely through interfaces. This design delivers flexibility without ambiguity, making interfaces a cornerstone of robust Java architecture.