Adapter Design Pattern

Object adapters use a compositional technique to adapt one interface to another.    The adapter inherits the target interface that the client expects to see, while it holds an instance the adaptee.   When the client calls the request() method on its target object (the adapter), the request is translated into the corresponding specific request on the adaptee. The target may be of an abstract class type (shown below) or of an interface type. In either case, the the forwarded request would be an overridden abstract method in the concrete adapter implementation.

Figure 1: Object adapter implementation of the Adapter Design Pattern.

Object adapters enable the client and the adaptee to be completely decoupled from each other.   Only the adapter knows about both of them.

public class Controller {

    private Model myModel;
    private View myView;

    public Controller() {
        myModel = new Model( new IModel2ViewAdapter() {
            public void request2View() {
                myView.handleModelRequest();  // myView is in scope!
            }
        });

        myView = new View( new IView2ModelAdapter() {
            public void request2Model() {
                myModel.handleViewRequest(); // myModel is in scope!
            }
        });
    }
} 

Class adapters use multiple inheritance to achieve their goals.   As in the object adapter, the class adapter inherits the interface of the client's target.   However, it also inherits the interface of the adaptee as well.   Since Java does not support true multiple inheritance, this means that one of the interfaces must be inherited from a Java interface type.   Note that either or both of the target or adaptee interfaces could be Java interface types. Below, the diagram shows the target as an abstract class type and the adaptee as an interface type.   The request to the target is simply rerouted to the specific request that was inherited from the adaptee interface.

Figure 2: Class adapter implementation of the Adapter Design Pattern.

Note that class adapters have a problem with name conflicts if methods of the same signature exist on both the target and the adaptee.  Note that just because two objects have methods that have the same signature (syntax), it does not guarantee that the two methods have the same meaning or behavior (sematics).    That is, the two methods do not necessarily map directly to each other.   Object adapters do not have this problem.

Class adapters are simpler than object adapters in that they involve fewer classes and are useful if total decoupling of the client and adaptee is not needed. Object adapters give better decoupling and are thus more flexible.