Why Interface‑Oriented Programming Makes Your Code Flexible and Extensible

What Is Interface‑Oriented Programming?

Besides procedural (PO) and object‑oriented (OO) programming, enterprise development often relies on interface‑oriented programming (Interface‑Oriented). An interface defines a contract that implementations must follow, allowing different modules to interact without knowing each other's internal details.

The most familiar real‑world example of an interface is a power socket: as long as a plug conforms to the socket standard, any brand or internal circuitry works, and a broken socket can be replaced with another that follows the same standard.

Similarly, when designing software architecture we first agree on the interfaces (method signatures) for each functionality. Implementations can then be swapped or extended without changing existing code.

Java provides the

interface

keyword, which is perfect for this style of programming.

Dream Scenario

Imagine a programmer who buys two cars—Wuling and Fit—and hires a driver to operate them.

<code>public class Wuling {
    public void drive() {
        System.out.println("驾驶五菱宏光汽车");
    }
}

public class Fit {
    public void drive() {
        System.out.println("驾驶飞度汽车");
    }
}
</code>

The driver defines two

drive()

methods, each accepting a specific car:

<code>public class Driver {
    public void drive(Wuling wuling) {
        wuling.drive(); // 驾驶五菱宏光的方法
    }
    public void drive(Fit fit) {
        fit.drive(); // 驾驶飞度的方法
    }
    public static void main(String[] args) {
        Wuling wuling = new Wuling();
        Fit fit = new Fit();
        Driver driver = new Driver();
        driver.drive(wuling);
        driver.drive(fit);
    }
}
</code>

When a new car (Alto) is added, the existing driver cannot handle it because its

drive()

methods only accept Wuling and Fit.

Decoupling the Code

Instead of modifying the driver each time, we introduce an abstract

Car

class with a generic

drive()

method, and let all specific cars extend it.

<code>public class Car {
    void drive() { }
}
</code>

Now Alto extends

Car

and provides its own implementation:

<code>public class Alto extends Car {
    public void drive() {
        System.out.println("驾驶奥拓汽车");
    }
}
</code>

The driver can accept a

Car

parameter, making it work for any future car without code changes:

<code>public class Driver {
    public void drive(Car car) {
        car.drive(); // 参数使用父类实现通用性
    }
    public static void main(String[] args) {
        Alto alto = new Alto();
        Driver driver = new Driver();
        driver.drive(alto);
    }
}
</code>

When a completely different vehicle, such as a donkey, appears, the original

drive()

method is unsuitable. We therefore define a broader

TrafficTools

interface that represents any transport mechanism.

<code>public interface TrafficTools {
    void drive(); // 通用的交通工具使用方法
}
</code>

All vehicles (cars, donkey, etc.) implement this interface:

<code>public class Car implements TrafficTools {
    @Override
    public void drive() { }
}

public class Donkey implements TrafficTools {
    @Override
    public void drive() {
        System.out.println("骑一头驴");
    }
}
</code>

The driver now works with any

TrafficTools

implementation:

<code>public class Driver {
    // 方法参数面向接口编程
    public void drive(TrafficTools trafficTools) {
        trafficTools.drive();
    }
    public static void main(String[] args) {
        Driver driver = new Driver();
        driver.drive(new Wuling());   // 开五菱
        driver.drive(new Fit());      // 开飞度
        driver.drive(new Alto());      // 开奥拓
        driver.drive(new Donkey());    // 骑驴
    }
}
</code>

Code Extensibility

Interface‑oriented design also simplifies adding new capabilities, such as flying planes. We define a

Plane

interface and a

PlaneDriver

implementation.

<code>public interface Plane {
    void fly();
}

public class PlaneDriver implements Plane {
    @Override
    public void fly() {
        System.out.println("专业的飞行员操控飞机");
    }
}
</code>

The travel service depends on the

Plane

interface, so any class that implements it can be used without changing existing code.

<code>public class Travel {
    public void fly(Plane plane) {
        plane.fly();
    }
    public static void main(String[] args) {
        Travel travel = new Travel();
        PlaneDriver planeDriver = new PlaneDriver();
        travel.fly(planeDriver); // 专业机长飞行
        // Our driver can also be upgraded to implement Plane
        Driver driver = new Driver();
        travel.fly(driver);
    }
}
</code>

This demonstrates the Open‑Closed Principle: we extend functionality by adding new classes that implement existing interfaces, without modifying the original code.

Real‑World Usage

Frameworks like Spring heavily rely on interfaces to separate contract from implementation, especially in the Service layer, which promotes maintainability and future extensions.

Conclusion

Interface‑oriented programming decouples code, enhances extensibility, and aligns with solid design principles, making it a valuable practice for everyday software development.