---
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.
```java
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.
```java
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.
```java
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`.
```java
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.