Interfaces & Abstract Classes

Real-world analogy: An interface is like a job description. It lists what the employee must be able to do (methods) — "must be able to write reports, attend meetings, meet deadlines" — but doesn't specify how they do it. Different employees (classes) fulfill the same job description in their own way.

Why interfaces matter: They allow you to write code that works with any implementation. A sorting function that accepts Comparable works with Strings, Integers, custom objects — anything that implements the interface.

// Define the contract
interface Drivable {
    void drive();       // what must be done
    void stop();        // no implementation — just the signature
    int getSpeed();
}

// Fulfill the contract — must implement ALL methods
class Car implements Drivable {
    private int speed = 0;
    public void drive() { speed = 60; System.out.println("Car driving"); }
    public void stop()  { speed = 0;  System.out.println("Car stopped"); }
    public int getSpeed() { return speed; }
}

class Bicycle implements Drivable {
    private int speed = 0;
    public void drive() { speed = 15; System.out.println("Pedaling"); }
    public void stop()  { speed = 0;  System.out.println("Braking"); }
    public int getSpeed() { return speed; }
}

// Now any method accepting Drivable works with both!
void testDrive(Drivable vehicle) {
    vehicle.drive();
    System.out.println("Speed: " + vehicle.getSpeed());
    vehicle.stop();
}

Analogy: An abstract class is like a partially built house. The foundation and framing are done (concrete methods), but you need to choose the paint color and flooring (abstract methods). You can't move into a half-built house (can't instantiate), but it gives every finished house a common structure.

abstract class Shape {
    String color;      // shared field

    Shape(String color) { this.color = color; }

    abstract double area();   // MUST be implemented by children

    void describe() {         // shared implementation — all shapes get this
        System.out.println(color + " shape, area = " + 
                           String.format("%.2f", area()));
    }
}

class Circle extends Shape {
    double radius;
    Circle(String color, double r) { super(color); radius = r; }
    double area() { return Math.PI * radius * radius; }
}

class Rectangle extends Shape {
    double w, h;
    Rectangle(String color, double w, double h) { super(color); this.w = w; this.h = h; }
    double area() { return w * h; }
}

// Shape s = new Shape("Red");  // ERROR! Can't instantiate abstract class
Shape s = new Circle("Red", 5);
s.describe(); // "Red shape, area = 78.54" — polymorphism works!

Java doesn't allow multiple inheritance (extending two classes), but a class can implement multiple interfaces. Since Java 8, interfaces can also have default methods with implementations:

interface Flyable {
    void fly();
    default void land() { System.out.println("Landing safely"); }
}

interface Swimmable {
    void swim();
    default void dive() { System.out.println("Diving deep"); }
}

// A Duck can do both!
class Duck implements Flyable, Swimmable {
    public void fly()  { System.out.println("Duck flies"); }
    public void swim() { System.out.println("Duck swims"); }
    // Inherits default land() and dive() for free!
}

Duck d = new Duck();
d.fly();   d.land();   // from Flyable
d.swim();  d.dive();   // from Swimmable