Interfaces: The Ultimate Contract

While an Abstract Class is a "half-finished" blueprint, an Interface is a contract. It defines a set of behaviors that a class must have, but it doesn't provide any of the logic itself.

If a class "implements" an interface, it is signing a legal document saying: "I promise to provide my own version of every method listed in this interface."

1. Key Characteristics

• Multiple Implementation: Unlike classes (where you can only extend one), a class can implement multiple interfaces.
• Pure Abstraction: Traditionally, interfaces only contain abstract methods (methods with no bodies).
• Keywords: We use the interface keyword to define it and implements to use it.

2. Interface Syntax

interface Powerable {
    void turnOn();  // No body, just the requirement
    void turnOff();
}

When a class signs this contract:

class Laptop implements Powerable {
    @Override
    public void turnOn() {
        System.out.println("Displaying logo... loading OS...");
    }

    @Override
    public void turnOff() {
        System.out.println("Shutting down safely.");
    }
}

3. Interfaces vs. Abstract Classes

💻 Full Practical Example: The Smart Home

Copy this code to see how one class can follow multiple "contracts":

interface Connectable {
    void connectToWifi();
}

interface Alarm {
    void triggerAlarm();
}

// A SmartCamera is BOTH a Connectable device AND an Alarm
class SmartCamera implements Connectable, Alarm {
    @Override
    public void connectToWifi() {
        System.out.println("Camera connected to 'Home_Network'.");
    }

    @Override
    public void triggerAlarm() {
        System.out.println("ALERT! Motion detected! Sending notification.");
    }
}

public class Main {
    public static void main(String[] args) {
        SmartCamera cam = new SmartCamera();
        cam.connectToWifi();
        cam.triggerAlarm();
    }
}

4. Modern Interfaces (Default Methods)

Since Java 8, interfaces can actually have methods with bodies if you use the default keyword. This allows you to add new features to interfaces without breaking the classes that already use them.

interface Vehicle {
    void move();

    default void honk() {
        System.out.println("Standard beep!");
    }
}

💡 Challenge: The Media Player

1. Create an interface Playable with methods play() and stop().
2. Create an interface Recordable with a method record().
3. Create a class Smartphone that implements both.
4. Create a class VinylPlayer that implements only Playable.
5. In main, show that the Smartphone can record, but the VinylPlayer cannot.