knowledge/technology/dev/programming/patterns/structural/Adapter Pattern.md

obj
concept

Adapter Pattern

Description:

The Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces, enabling them to collaborate without altering their source code. The Adapter Pattern is useful when you want to reuse existing classes or integrate third-party libraries that don't quite fit your desired interface.

How it's Used:

1. Identify Interfaces: Identify the two interfaces that need to work together but are incompatible.
2. Adapter Class: Create an adapter class that implements the interface expected by the client code (the target interface) while containing an instance of the class with the incompatible interface (the adaptee).
3. Adapter Methods: Within the adapter class, implement methods that map the methods of the target interface to the corresponding methods of the adaptee interface.
4. Client Code: In the client code, use the adapter class to interact with the adaptee class as if it implements the target interface.

Example:

Suppose you have a legacy class OldSystem with an interface that is incompatible with your modern system, but you need to integrate the legacy functionality. Here's how the Adapter Pattern can be applied:

• Incompatible Legacy Class (Adaptee): Define the OldSystem class with its existing interface.

public class OldSystem {
    public void doOldStuff() {
        System.out.println("Doing old stuff in the legacy system.");
    }
}

• Target Interface: Define the NewSystem interface that your modern system expects.

public interface NewSystem {
    void doNewStuff();
}

• Adapter Class: Create an adapter class Adapter that implements the NewSystem interface and contains an instance of the OldSystem class.

public class Adapter implements NewSystem {
    private OldSystem oldSystem;

    public Adapter(OldSystem oldSystem) {
        this.oldSystem = oldSystem;
    }

    @Override
    public void doNewStuff() {
        // Delegate the new system's request to the old system's method
        oldSystem.doOldStuff();
    }
}

• Client Code: In your modern system, use the Adapter class to work with the OldSystem as if it were a NewSystem.

public class Client {
    public static void main(String[] args) {
        OldSystem legacySystem = new OldSystem();
        NewSystem adapter = new Adapter(legacySystem);

        // Use the adapter to perform new system operations
        adapter.doNewStuff();
    }
}

By using the Adapter Pattern, you can integrate the legacy OldSystem class seamlessly into your modern system without changing the code of the legacy class. The adapter serves as a bridge, translating calls from the new system's interface to the old system's interface, allowing them to work together.