Adapter Pattern
This pattern establishes
a relationship between the two unrelated interfaces such that they work together.
This is similar to the conversion of one
interface of one class to the interface expected by the client. To understand
clearly lets take an example:
Suppose there are several sockets of
different sizes, and shapes in a house. Due to variation in sizes, all the sockets are not capable
of plug-in a mobile charger. So we use an Adapter to make it portable across
different sockets. Here Adapter works as a connector. This connector connects
them together and meets the purpose of the client.
Benefits: It helps the developers to relate the unrelated
class such that they may work together. It provides compatibility between the
classes and increases the transparency. Additionally it provides a pluggable kit, delegates objects,
makes the classes highly reusable and achieves the goal through inheritance or
composition.
It also tries to match the interfaces such as WindowAdapter, KeyAdapter, MouseAdapter, ContainerAdapter,
ComponentAdapter, FocusAdapter and MouseMotionAdapter.
Usage: The adapter pattern is
meant to use an existing class to fulfill the client's class requirements. For
example, suppose a client specifies his requirement in an interface, and then
to meet the purpose usually a class is created that implements the required interface and inherits the existing
class into the subclasses. This approach creates a class known as the adapter class
which translates the client's calls to the existing class methods. Adapter pattern also
helps to make
improvements in the new code and to make the code more manageable. It improves the performance while
designing the system.
Now think all such things technically and try to
resolve the problem. There are two ways of implementing the Adapter Pattern,
either use the Inheritance or use the composition.
Let's do it with the approach of
Inheritance.
First develop a socket interface as:
Switch.java
public interface Switch {
public void switchOn();
public void switchOff();
}
|
Implement Switch.java in a class say Fan
class. The class is given below :
Fan. java
public class Fan implements Switch{
public void switchOn() {
System.out.println("FAN Switched ON");
}
public void switchOff() {
System.out.println("FAN Switched OFF");
}
public static void main(String arg[]){
Fan f = new Fan();
f.switchOn();
f.switchOff();
}
}
|
Here is the output of the above Fan.java
program :
C:\>javac Fan.java
C:\>java Fan
Fan Switched ON
Fan Switched OFF |
Finally, there will be an adapter class. This will inherit the Switch and give output for
Fan.
Bulb.java:
public class Bulb implements Switch {
public void switchOn() {
System.out.println("BULB Switched ON");
}
public void switchOff() {
System.out.println("BULB Switched OFF");
}
}
|
Here is the output of the above Bulb.java program:
C:\>javac Bulb.java
C:\>java Bulb
Bulb Switched ON
Bulb Switched OFF |
Similarly, let’s consider the Association and Composition of objects by which Adapter can be implemented.
The above example shows how Adapter pattern works. When one interface cannot be changed and
needed to suit again a cannot-be-changed client, then an adapter is used so that both the interfaces
work together.
|
Del.icio.us
Digg
Google
Spurl
Blink
Furl
Simpy
Y! MyWeb
