Structural Patterns Part 1: Adapter, Bridge, and Facade

Adapter Pattern

Adapter converts one interface into another that the client expects. It is extremely useful when integrating legacy code, third-party SDKs, vendor APIs, or old internal libraries.

class LegacyPrinter {
    public void printText(String text) {
        System.out.println(text);
    }
}

interface Printer {
    void print(String text);
}

class LegacyPrinterAdapter implements Printer {
    private final LegacyPrinter legacyPrinter = new LegacyPrinter();

    @Override
    public void print(String text) {
        legacyPrinter.printText(text);
    }
}

Bridge Pattern

Bridge separates abstraction from implementation so the two can vary independently. It is helpful when multiple dimensions of variation exist. For example, shape type and rendering engine, or notification type and delivery provider. Without Bridge, inheritance combinations can explode quickly.

Facade Pattern

Facade provides a simplified interface over a complex subsystem. A payment facade may coordinate validation, tax computation, inventory reservation, fraud checks, and external gateway calls while exposing one clean method such as placeOrder().

public class OrderFacade {
    public void placeOrder(Order order) {
        validate(order);
        reserveInventory(order);
        chargePayment(order);
        createShipment(order);
    }

    private void validate(Order order) {}
    private void reserveInventory(Order order) {}
    private void chargePayment(Order order) {}
    private void createShipment(Order order) {}
}

Pattern Comparison

• Adapter changes an interface.
• Bridge separates abstraction and implementation.
• Facade simplifies a subsystem.

They may appear similar at first because all three sit between clients and implementation details, but their intent is different. Understanding intent prevents misuse.

Real-World Usage Snapshot

Adapters are common in integration code, facades are common in service orchestration, and bridge-like designs appear in cloud abstraction layers, pluggable rendering systems, and strategy-based domain models. These patterns are especially important in enterprise Java where libraries and platforms evolve over time.