Adapter Design Patterns
Lecture 21
Adapter Design Pattern
Gang of Four state the intent of Adapter is to
Convert the interface of a class into another interface that
the clients expect. Adapter lets classes work together that
could not otherwise because of incompatible interfaces.
Problem Specification:
Step 1:
You are given the following class library to draw
shapes.
Shape
+display()
+fill()
+undisplay()
Line Square
+display() +display()
+fill() +fill()
+undisplay() +undisplay()
Step 2:
Now you are asked to add another class to deal
with circle. Your plan was:
Shape
+display()
+fill()
+undisplay()
Circle
Line Square
+display() +display()
+fill() +display()
+fill() +fill()
+undisplay() +undisplay() +undisplay()
Step 3:
Then your client said: “No,no,no”. You have to use this
nice class library for drawing circles. Unfortunately, it is
from a different vendor and it has a different interface.
Shape
+display()
+fill()
AnotherCircle
+undisplay()
+setLocation()
+drawIt()
+fillIt()
+setItColor()
Line Square +unDrawIt()
+display() +display()
+fill() +fill()
+undisplay() +undisplay()
Adapter Design Pattern
Problem: An "off the shelf" component offers
compelling functionality that you would like to reuse,
but its "view of the world" is not compatible with the
philosophy and architecture of the new system
Adapter is about creating an intermediary abstraction
that translates, or maps, the old component to the new
system
Use Adapter when you need a way to create a new
interface for an object that does the right stuff but has
the wrong interface
Two kinds of adapter pattern
Object adapter pattern
The adapter class contains adaptee object
Class adapter pattern
Adapter class is inherited from both adaptee and
abstract class.
Object Adapter
AbstractClass
AdapterClass AdapteeClass
Adapter Design Pattern Solution
Object Adapter
Shape
+display()
adaptee
+fill()
+undisplay()
AnotherCircle
Line Circle
Square
+display() -aCircle:AnotherCircle +setLocation()
+display()
+fill() +drawIt()
+fill() +display()
+undisplay() +fillIt()
+undisplay() +fill() +setItColor()
+undisplay() +unDrawIt()
void display(){ void fill(){ void undisplay(){
aCircle.drawIt(); aCircle.fillIt(); aCircle.unDrawIt();
} } }
Class Adapter
AbstractClass AdapteeClass
AdapterClass
Adapter Design Pattern Solution
Class Adapter
AnotherCircle
Shape
+setLocation()
+drawIt()
+display() +fillIt()
+fill() +setItColor()
+undisplay() +unDrawIt()
Line Square Circle
+display() +display()
+fill() +fill() +display()
+undisplay() +undisplay() +fill()
+undisplay()
void display(){ void fill(){ void undisplay(){
drawIt(); fillIt(); unDrawIt();
} } }
Class Adapter Vs Object Adapter
Class Adapter
uses inheritance and can only wrap a class. It cannot
wrap an interface since by definition it must derive
from some base class.
Object Adapter
uses composition and can wrap classes or interfaces, or
both. It can do this since it contains, as a private,
encapsulated member, the class or interface object
instance it wraps.
Goal of Adapter Pattern
Keeping the client code intact we need to write a
new class which will make use of services offered
by the class.
Convert the services offered by class to the client
in such a way that functionality will not be
changed and the class will become reusable.
Flow of Events in Adapter
Pattern
Client call operations on Adaptor instance, which
in return call adaptee opertions that carry out the
request.
To use an adapter:
The client makes a request to the adapter by calling a method on it
using the target interface.
The adapter translates that request on the adaptee using the adaptee
interface.
Client receive the results of the call and is unaware of adapter’s
presence.
Implementation steps
Identify the desired interface.
Design a "wrapper" class that can "impedance
match" the old to the new.
The adapter/wrapper class "has a" instance of the
legacy class.
The adapter/wrapper class "maps" (or delegates)
to the legacy object.
The client uses (is coupled to) the new interface.
Components of Adapter Class
1. Adaptee: Defines an existing interface that needs
adapting; it represents the component with which the
client wants to interact with.
2. Target: Defines the domain-specific interface that the
client uses; it basically represents the interface of the
adapter that helps the client interact with the adaptee.
3. Adapter: Adapts the interface Adaptee to the Target
interface; in other words, it implements the Target
interface, defined above and connects the adaptee, with
the client, using the target interface implementation
4. Client: The main client that wants to get the operation, is
done from the Adaptee.
Limitations of Adapter Design
Pattern
Due to adapter class the changes are encapsulated
within it and client is decoupled from the changes
in the class.
A client in video game wants to use an enemy
attacker. Any enemy attacker can fire a weapon,
drive forward and assign driver to it. However,
you want to create an artificially intelligent enemy
robot. Now, an enemy robot has no need for a
driver and also it is not going to drive forward ,it’s
going to walk forward, and has no weapons it just
smashes things with its feet's and its hand. We
want to see enemy robot as an enemy attacker.
Step 1:Create interface for
Enemy Attacker
// This is the Target Interface : This is what the client
// expects to work with. It is the adapters job to make new
// classes compatible with this one.
public interface EnemyAttacker {
public void fireWeapon();
public void driveForward();
public void assignDriver(String driverName);
}
Step 2:
// EnemyTank implements EnemyAttacker perfectly
// Our job is to make classes with different methods
// from EnemyAttacker to work with the EnemyAttacker interface
import java.util.Random;
public class EnemyTank implements EnemyAttacker{
Random generator = new Random();
public void fireWeapon() {
int attackDamage = generator.nextInt(10) + 1;
System.out.println("Enemy Tank Does " + attackDamage + " Damage");}
public void driveForward() {
int movement = generator.nextInt(5) + 1;
System.out.println("Enemy Tank moves " + movement + " spaces");}
public void assignDriver(String driverName) {
System.out.println(driverName + " is driving the tank"); }
}
Step 3: Adaptee
// This is the Adaptee. The Adapter sends method calls
// to objects that use the EnemyAttacker interface
// to the right methods defined in EnemyRobot
import java.util.Random;
public class EnemyRobot{
Random generator = new Random();
public void smashWithHands() {
int attackDamage = generator.nextInt(10) + 1;
System.out.println("Enemy Robot Causes " + attackDamage + " Damage
With Its Hands"); }
public void walkForward() {
int movement = generator.nextInt(5) + 1;
System.out.println("Enemy Robot Walks Forward " + movement + "
spaces"); }
public void reactToHuman(String driverName) {
System.out.println("Enemy Robot Tramps on " + driverName);
}
Step 4:Adapter
// The Adapter must provide an alternative action for
// the the methods that need to be used because
// EnemyAttacker was implemented.
// This adapter does this by containing an object
// of the same type as the Adaptee (EnemyRobot)
// All calls to EnemyAttacker methods are sent
// instead to methods used by EnemyRobot
public class EnemyRobotAdapter implements EnemyAttacker{
EnemyRobot theRobot;
public EnemyRobotAdapter(EnemyRobot newRobot){
theRobot = newRobot; }
public void fireWeapon() {
theRobot.smashWithHands(); }
public void driveForward() {
theRobot.walkForward(); }
Step 4:Adapter
public void assignDriver(String driverName) {
theRobot.reactToHuman(driverName);
}
Step 5: Client
public class TestEnemyAttackers{
public static void main(String[] args){
EnemyTank rx7Tank = new EnemyTank();
EnemyRobot fredTheRobot = new EnemyRobot();
EnemyAttacker robotAdapter = new EnemyRobotAdapter(fredTheRobot);
System.out.println("The Robot");
fredTheRobot.reactToHuman("Paul");
fredTheRobot.walkForward();
fredTheRobot.smashWithHands();
System.out.println();
System.out.println("The Enemy Tank");
rx7Tank.assignDriver("Frank");
rx7Tank.driveForward();
rx7Tank.fireWeapon();
System.out.println();
Step 5: Client
System.out.println("The Robot with Adapter");
robotAdapter.assignDriver("Mark");
robotAdapter.driveForward();
robotAdapter.fireWeapon();
}
Output
