Adapter Pattern in Java with examples

The Adapter Pattern is a design pattern in software development that allows two incompatible interfaces to work together. This pattern is used when an existing class cannot be modified but needs to be integrated with other classes that expect a different interface. The adapter pattern solves this problem by creating an adapter class that acts as a bridge between the two interfaces, allowing the classes to work together.

Understanding the Adapter Pattern in Java

In Java, the adapter pattern can be implemented in two ways: class adapter and object adapter. The class adapter pattern uses inheritance to adapt the target interface, while the object adapter pattern uses composition to adapt the target interface.

Here’s a simple example of the class adapter pattern in Java:

interface Target {
    void request();
}

class Adaptee {
    void specificRequest() {
        System.out.println("Specific request");
    }
}

class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest();
    }
}

public class Main {
    public static void main(String[] args) {
        Target target = new ClassAdapter();
        target.request();
    }
}

And here’s a simple example of the object adapter pattern in Java:

interface Target {
    void request();
}

class Adaptee {
    void specificRequest() {
        System.out.println("Specific request");
    }
}

class ObjectAdapter implements Target {
private Adaptee adaptee;

    ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public class Main {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

Benefits of Using the Adapter Pattern in Java

The adapter pattern provides a number of benefits, including:

• Loose coupling: By using an adapter, the client code and the adaptee code are loosely coupled, meaning that changes to one class do not affect the other class.
• Reusability: The adapter pattern allows existing classes to be reused in new systems, even if they have different interfaces.
• Flexibility: The adapter pattern can be used to integrate new systems with existing systems, making it possible to add new functionality without modifying existing code.

When to Use the Adapter Pattern in Java

The adapter pattern should be used when:

• You need to integrate an existing class into a new system, but the existing class cannot be modified.
• You need to convert the interface of an existing class into a different interface that is expected by the client code.
• You want to make it possible to add new functionality to an existing system without modifying existing code.

Conclusion

The Adapter Pattern is a useful design pattern in Java that allows two incompatible interfaces to work together. By creating an adapter class that acts as a bridge between the two interfaces, the adapter pattern makes it possible to reuse existing code and add new functionality to existing systems. Whether you’re working with class adapters or object adapters, the adapter pattern provides a flexible and reusable solution for integrating different systems and components.