🔰 Introduction

In Java, an interface is a powerful feature used to define a contract that classes must follow. It plays a crucial role in:

• ✅ Abstraction
• ✅ Multiple inheritance
• ✅ Loose coupling
• ✅ Scalable system design

👉 Think of an interface as a rulebook — any class that agrees to it must implement all its methods.

---

🧩 What is an Interface?

An interface contains:

• Abstract methods (by default)
• Constants (public static final)

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

👉 Behind the scenes:

public abstract void makeSound();

---

⚙️ How Interface Works

A class uses implements keyword to adopt an interface:

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

💡 Explanation:

• Dog agrees to follow Animal
• Must implement makeSound()
• Method must be public

---

🚀 Full Working Example

interface Vehicle {
    void start();
    void stop();
}

class Bike implements Vehicle {
    public void start() {
        System.out.println("Bike starts");
    }

    public void stop() {
        System.out.println("Bike stops");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle v = new Bike();
        v.start();
        v.stop();
    }
}

🔍 Output:

Bike starts
Bike stops

👉 This demonstrates:

• Runtime polymorphism
• Interface-based design

---

⚡ Types of Methods in Interface

---

1️⃣ Abstract Method (Default Behavior)

interface Test {
    void show();
}

👉 Must be implemented in class.

---

2️⃣ Default Method (Java 8+)

interface Test {
    default void display() {
        System.out.println("Default method");
    }
}

👉 Provides implementation inside interface.

---

3️⃣ Static Method

interface Test {
    static void print() {
        System.out.println("Static method");
    }
}

👉 Called using:

Test.print();

---

4️⃣ Private Method (Java 9+)

interface Test {
    private void helper() {
        System.out.println("Helper method");
    }
}

👉 Used internally within interface.

---

🔗 Multiple Inheritance Using Interface

Java doesn’t allow multiple inheritance with classes, but interfaces make it possible.

---

🧩 Example: Multiple Inheritance

interface A {
    void show();
}

interface B {
    void display();
}

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

    public void display() {
        System.out.println("Display from B");
    }
}

💡 Explanation:

• Demo implements both A and B
• Must override both methods
• Achieves multiple inheritance safely

---

🌐 Hybrid Inheritance Using Interfaces

👉 Hybrid inheritance = combination of multiple + hierarchical inheritance

---

🧩 Example:

interface A {
    void methodA();
}

interface B extends A {
    void methodB();
}

interface C extends A {
    void methodC();
}

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

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

    public void methodC() {
        System.out.println("Method C");
    }
}

---

💡 Explanation:

• B and C extend A → hierarchical
• D implements both → multiple
• Combined = Hybrid inheritance

---

🧠 Working of Abstract Method in Interface

interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

🔍 Flow:

1. Interface defines method
2. Class implements it
3. Object calls method → runtime binding

---

🧠 Working of Abstract Method in Abstract Class

abstract class Shape {
    abstract void draw();

    void info() {
        System.out.println("Shape class");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing Circle");
    }
}

---

🔍 Key Working:

• Abstract method must be implemented
• Concrete methods can be reused

---

⚔️ Interface vs Abstract Class (Deep Comparison)

---

📊 Detailed Table

Feature	Interface	Abstract Class
🔹 Purpose	Contract	Base class
🔹 Methods	Abstract + Default + Static	Abstract + Concrete
🔹 Variables	Constants only	Instance variables allowed
🔹 Constructor	❌ No	✅ Yes
🔹 Inheritance	Multiple	Single
🔹 Access Modifiers	Public only (default)	Any
🔹 Speed	Slightly faster	Slightly slower
🔹 Use Case	Loose coupling	Code reuse

---

🔥 Code Comparison

Interface

interface Animal {
    void sound();
}

---

Abstract Class

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

---

⚠️ Common Errors & Confusions

---

❌ 1. Missing public keyword

class Dog implements Animal {
    void sound() {} // ERROR
}

✔️ Fix:

public void sound() {}

---

❌ 2. Object creation of interface

Animal a = new Animal(); // ❌

✔️ Use:

Animal a = new Dog();

---

❌ 3. Not implementing all methods

👉 Leads to compilation error

---

❌ 4. Confusion about variables

interface Test {
    int x = 10;
}

👉 Actually:

public static final int x = 10;

---

🎯 When to Use Interface?

• 🔹 When you need multiple inheritance
• 🔹 When designing APIs
• 🔹 When flexibility is required
• 🔹 When behavior matters more than implementation

---

🎯 When to Use Abstract Class?

• 🔹 When classes are closely related
• 🔹 When you want shared code
• 🔹 When you need constructors

---

🏁 Conclusion

Interfaces are a cornerstone of modern Java development. They help in:

• ✨ Building flexible systems
• 🔄 Achieving polymorphism
• 🧩 Supporting multiple & hybrid inheritance

With modern enhancements (Java 8+), interfaces are no longer just abstract — they are powerful design tools.

👉 Key takeaway:

• Interface = What to do
• Abstract class = What + How