Interfaces & Abstract Classes

While Abstract Classes provide a partially implemented blueprint (with both abstract and concrete methods), Interfaces define a purely behavioral contract with zero implementation. Understanding when to use each is a critical design decision in professional OOP development.

1. What is an Interface?

An Interface in Java is a reference type, similar to a class, that can contain only abstract methods (prior to Java 8) and constants. It specifies what a class must do, but not how it does it.

A class that implements an interface must provide concrete implementations for ALL methods declared in the interface.

interface Flyable {
    void takeOff();
    void fly(int altitude);
    void land();
}

class Airplane implements Flyable {
    public void takeOff() { System.out.println("Runway acceleration"); }
    public void fly(int altitude) { System.out.println("Cruising at " + altitude + " feet"); }
    public void land() { System.out.println("Landing gear deployed"); }
}

class Bird implements Flyable {
    public void takeOff() { System.out.println("Flapping wings"); }
    public void fly(int altitude) { System.out.println("Soaring at " + altitude + " feet"); }
    public void land() { System.out.println("Perching on branch"); }
}

Both Airplane and Bird are completely unrelated classes, but they both fulfill the Flyable contract.

2. Java 8+ Interface Evolution

Starting with Java 8, interfaces gained new capabilities:

• Default Methods: Methods with a body (using the default keyword). This allows adding new methods to existing interfaces without breaking all implementing classes.
• Static Methods: Utility methods that belong to the interface itself.

interface Loggable {
    void log(String message);

    // Default method: implementing classes get this for free
    default void logError(String message) {
        log("ERROR: " + message);
    }
}

3. Solving the Diamond Problem

Recall that Java bans multiple inheritance of classes because of the Diamond Problem. However, Java allows a class to implement multiple interfaces simultaneously. This provides the benefits of multiple inheritance without the ambiguity.

interface Swimmable {
    void swim();
}

interface Flyable {
    void fly();
}

// A Duck can both swim AND fly
class Duck implements Swimmable, Flyable {
    public void swim() { System.out.println("Paddling"); }
    public void fly() { System.out.println("Flapping"); }
}

4. Abstract Class vs. Interface

When to use which?

• Use an Abstract Class when you want to share code (fields, concrete methods) among several closely related classes.
• Use an Interface when you want to define a capability that can be shared by unrelated classes (like Serializable, Comparable, Runnable).