📘Interfaces in Java

1. What is an Interface?

An interface is a blueprint of a class.

It contains:

• Method declarations (by default public abstract)
• Constants (public static final)
• From Java 8+: default + static methods
• From Java 9+: private methods (helper methods)

Example:

interface Animal {
    void eat();     // abstract method
}
        

Usage:

class Dog implements Animal {
    public void eat() {
        System.out.println("Dog eats");
    }
}
        

👉 A class implements an interface. 👉 It MUST provide implementations for all abstract methods.

2. Why Interfaces Exist

Java does NOT allow multiple inheritance with classes.

You cannot do this:

class C extends A, B { }  // ❌ illegal
        

Because of the Diamond Problem (ambiguity).

So Java uses interfaces to achieve multiple inheritance safely.

3. Multiple Inheritance Using Interfaces

Example:

interface A {
    void show();
}

interface B {
    void show();
}

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

This is VALID.

Why?

Because interfaces don’t carry implementation (mostly). So Java forces YOU to resolve the conflict.

👉 No ambiguity.

4. Diamond Problem Explained

   A
  / \
 B   C
  \ /
   D
        

If A has print() B and C inherit it D inherits B and C.

Which print() should D use?

Java avoids this by not allowing multiple class inheritance.

Interfaces solve it because:

• Methods are abstract
• Child must implement explicitly

5. Default Methods Conflict (Java 8+)

If interfaces have default methods:

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

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

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

👉 Compiler forces override.

No silent ambiguity.

6. Key Rules

✔ Class → Class

Single inheritance only

class B extends A
        

✔ Interface → Interface

Multiple allowed

interface C extends A, B
        

✔ Class → Interfaces

Multiple allowed

class Test implements A, B, C
        

❌ Interface → Class

Not allowed.