It is very similar to the electrical engineering activity of "impedance matching" – adapting the input resistance, inductance, and capacitance of a load to match the output impedance of a source.
Adapter is about creating an intermediary abstraction that translates, or maps, the old component to the new system. Clients call methods on the Adapter object which redirects them into calls to the legacy component. This strategy can be implemented either with inheritance or with aggregation.
Adapter functions as a wrapper or modifier of an existing class. It provides a different or translated view of that class.
display() method
expects to receive "x, y, w, h" parameters. But the client wants
to pass "upper left x and y" and "lower right x and y". This
incongruity can be reconciled by adding an additional level of
indirection – i.e. an Adapter object.
The Adapter could also be thought of as a "wrapper".
| Before | After | |||
|---|---|---|---|---|
// BEFORE - Because the interface between Line and
// Rectangle objects is incapatible, the user has to
// recover the type of each shape and manually supply
// the correct arguments.
// AFTER - The Adapter's "extra level of indirection"
// takes care of mapping a user-friendly common interface
// to legacy-specific peculiar interfaces.
class LegacyLine {
public void draw( int x1, int y1, int x2, int y2 ) {
System.out.println( "line from (" + x1 + ',' + y1
+ ") to (" + x2 + ',' + y2 + ')' );
} }
class LegacyRectangle {
public void draw( int x, int y, int w, int h ) {
System.out.println( "rectangle at (" + x + ',' + y
+ ") with width " + w + " and height " + h );
} }
public class AdapterDemo {
public static void main( String[] args ) {
Object[] shapes = { new LegacyLine(),
new LegacyRectangle() };
// A begin and end point from a graphical editor
int x1 = 10, y1 = 20;
int x2 = 30, y2 = 60;
for (int i=0; i < shapes.length; ++i)
if (shapes[i].getClass().getName()
.equals("LegacyLine"))
((LegacyLine)shapes[i]).draw( x1, y1, x2, y2 );
else if (shapes[i].getClass().getName()
.equals("LegacyRectangle"))
((LegacyRectangle)shapes[i]).draw(
Math.min(x1,x2), Math.min(y1,y2),
Math.abs(x2-x1), Math.abs(y2-y1) );
} }
// line from (10,20) to (30,60)
// rectangle at (10,20) with width 20 and height 40
|
class LegacyLine {
public void draw( int x1, int y1, int x2, int y2 ) {
System.out.println( "line from (" + x1 + ',' + y1
+ ") to (" + x2 + ',' + y2 + ')' );
} }
class LegacyRectangle {
public void draw( int x, int y, int w, int h ) {
System.out.println( "rectangle at (" + x + ',' + y
+ ") with width " + w + " and height " + h );
} }
interface Shape {
void draw( int x1, int y1, int x2, int y2 );
}
class Line implements Shape {
private LegacyLine adaptee = new LegacyLine();
public void draw( int x1, int y1, int x2, int y2 ) {
adaptee.draw( x1, y1, x2, y2 );
} }
class Rectangle implements Shape {
private LegacyRectangle adaptee = new LegacyRectangle();
public void draw( int x1, int y1, int x2, int y2 ) {
adaptee.draw( Math.min(x1,x2), Math.min(y1,y2),
Math.abs(x2-x1), Math.abs(y2-y1) );
} }
public class AdapterDemo {
public static void main( String[] args ) {
Shape[] shapes = { new Line(), new Rectangle() };
// A begin and end point from a graphical editor
int x1 = 10, y1 = 20;
int x2 = 30, y2 = 60;
for (int i=0; i < shapes.length; ++i)
shapes[i].draw( x1, y1, x2, y2 );
} }
// line from (10,20) to (30,60)
// rectangle at (10,20) with width 20 and height 40
|
Bridge is designed up-front to let the abstraction and the implementation vary independently. Adapter is retrofitted to make unrelated classes work together. [GoF, p161]
Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface. [GoF. p216]
Adapter is meant to change the interface of an existing object. Decorator enhances another object without changing its interface. Decorator is thus more transparent to the application than an adapter is. As a consequence, Decorator supports recursive composition, which isn't possible with pure Adapters. [GoF, 149]
Facade defines a new interface, whereas Adapter reuses an old interface. Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one. [GoF, pp219]