Field Notes: The Adapter Pattern
Often, I will be in a situation similar to the one above, but the object being adapted does not do all the things I need.
In this case, I can still use the Adapter pattern, but it is not such a perfect fit. In this case,
Those functions that are implemented in the existing class can be adapted.
Those functions that are not present can be implemented in the wrapping object.
This does not give me quite the same benefit, but at least I do not have to implement all of the required functionality.
The Adapter pattern frees me from worrying about the interfaces of existing classes when I am doing a design. If I have a class that does what I need, at least conceptually, then I know that I can always use the Adapter pattern to give it the correct interface.
This will become more important as you learn a few more patterns. Many patterns require certain classes to derive from the same class. If there are preexisting classes, the Adapter pattern can be used to adapt it to the appropriate abstract class (as Circle adapted XXCircle to Shape).
There are actually two types of Adapter patterns:
Object Adapter pattern— The Adapter pattern I have been using is called an Object Adapter because it relies on one object (the adapting object) containing another (the adapted object).
Class Adapter pattern— Another way to implement the Adapter pattern is with multiple inheritance. In this case, it is called a Class Adapter pattern.
The decision of which Adapter pattern to use is based on the different forces at work in the problem domain. At a conceptual level, I may ignore the distinction; however, when it comes time to implement it, I need to consider more of the forces involved.[3]
[3] For help in deciding between Object Adapter and Class Adapter, see pages 142–144 in the Gang of Four book.
In my classes on design patterns, someone almost always states that it sounds as if both the Adapter pattern and the Facade pattern are the same. In both cases there is a preexisting class (or classes) that does have the interface that is needed. In both cases, I create a new object that has the desired interface (see Figure 7-7).
Figure 7-7. A Client object using another, preexisting object with the wrong interface.
Wrappers and object wrappers are terms that you hear a lot about. It is popular to think about wrapping legacy systems with objects to make them easier to use.
At this high view, the Facade and the Adapter patterns do seem similar. They are both wrappers. But they are different kinds of wrappers. You need to understand the differences, which can be subtle. Finding and understanding these more subtle differences gives insight into a pattern's properties. Let's look at some different forces involved with these patterns (see Table 7-1).
| Facade | Adapter | |
|---|---|---|
| Are there preexisting classes? | Yes | Yes |
| Is there an interface we must design to? | No | Yes |
| Does an object need to behave polymorphically? | No | Probably |
| Is a simpler interface needed? | Yes | No |
Table 7-1 tells us the following:
In both the Facade and Adapter pattern I have preexisting classes.
In the Facade, however, I do not have an interface I must design to, as I do in the Adapter pattern.
I am not interested in polymorphic behavior in the Facade, while in the Adapter, I probably am. (There are times when we just need to design to a particular API and therefore must use an Adapter. In this case, polymorphism may not be an issue—that's why I say “probably”).
In the case of the Facade pattern, the motivation is to simplify the interface. With the Adapter, while simpler is better, I am trying to design to an existing interface and cannot simplify things even if a simpler interface were otherwise possible.
Sometimes people draw the conclusion that another difference between the Facade and the Adapter pattern is that the Facade hides multiple classes behind it while the Adapter only hides one. While this is often true, it is not part of the pattern. It is possible that a Facade could be used in front of a very complex object while an Adapter wrapped several small objects that between them implemented the desired function.
Bottom line: A Facade simplifies an interface while an Adapter converts the interface into a preexisting interface.