设计模式 （八）适配器模式(Adapter)

适配器模式(Adapter)就是由源到目标的一个适配，通常我们定义的接口或者类里面提供了好多方法，但是有时候用起来不是很符合，但是我们不能修改源码，那确实也不是一个好的方法，这样就提供了适配器这个类，用一个类来时源能匹配目标就可以了。

在Spring，IO里面都有这方面的设计，最简单的BeanUtils里面的转换器，就是当你没有定义相应的vo类似那个的时候，可以自动一个转化器然后应用就可以了。

适配器模式(Adapter)的简单的原理图：

这次我把UML类图也添加了备注，把图片放大了，这样方便查看和复习，同时清楚了实线空心箭头是“继承的”的意思，虚线空心箭头是“实现了”的意思，上面用的是去实现了，其实有的版本上面确切是是用实线箭头，就是关联的意思，其实表达出大致的意思就行了。

适配器模式有两种，一种是类适配器，一种是对象适配器，其宗旨都是解决源对于目标的不匹配，下面分别从简单的例子看两种适配器然后整体分析：

第一种适配器

我的电脑耳机坏了，但是我耳机是USB2.0的插口，不幸运的是我只有一个3.0的耳机了，于是我去买了一个适配器把3.0的和2.0的接到了一起，就能用了，事例代码如下：

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public interface USB2 {  
4.     public void need();  
5. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public class USB3 {  
4.     public void add() {  
5.         System.out.println("I'm a USB3.0 headset");  
6.     }  
7. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public class Adapter extends USB3 implements USB2 {  
4.   
5.     @Override  
6.     public void need() {  
7.         this.add();  
8.     }  
9.   
10. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3.   
4. public class Client {  
5.     public static void main(String[] args) {  
6.         Adapter adapter = new Adapter();  
7.         adapter.add();  
8.     }  
9. }  

这样就直接打印了：

[html] view plain copy

1. I'm a USB3.0 headset  

这样Adapter继承了USB3这个类，java中的单继承不允许它在继承别的类了，所以就不能再实现别的目标类的需求了，所以这样就叫做类适配器，量身为一个类做的一个适配器。其实这种类的适配模式用于单一源的适配，由于它的源的单一话，代码实现不用写选择逻辑，很清晰；而对象的适配模式则可用于多源的适配，弥补了类适配模式的不足，使得原本用类适配模式需要写很多适配器的情况不复存在，弱点是，由于源的数目可以较多，所以具体的实现条件选择分支比较多，不太清晰。同时在对象的适配器里面，通常是把源或者是目标聚合到适配器里面，就是和适配器拥有共同的生命周期，放在适配器的构造器里面，个人觉得在源放在放在适配器里面比较好，可能多数的时候是在适配器面接收目标的要求，然后通过对要求的分析，解析在用源的实例去调用源的方法的。

下面就简单的写了一个对象的适配器的例子：

我定义了一个类Utils简单的用List存放了三个字符串，作为我的源，但是我的Application用的时候是必须是HashMap，这样我就不能用了，于是定义的一个ListAdapter类，来解决这两个问题，具体代码如下：

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class Utils {  
7.   
8.     @SuppressWarnings("unchecked")  
9.     public static List getElements() {  
10.         List list = new ArrayList();  
11.         list.add("first");  
12.         list.add("second");  
13.         list.add("third");  
14.         return list;  
15.     }  
16. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. import java.util.HashMap;  
4.   
5. public class Application {  
6.   
7.     @SuppressWarnings("unchecked")  
8.     public static void print(HashMap map) {  
9.         for (int i = 0; i < map.size(); i++) {  
10.             System.out.print(map.get(i) + " ");  
11.         }  
12.     }  
13.   
14. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. import java.util.HashMap;  
4. import java.util.List;  
5.   
6. @SuppressWarnings( { "unchecked", "serial" })  
7. public class ListAdapter extends HashMap {  
8.   
9.     @SuppressWarnings("unchecked")  
10.     private List list;  
11.   
12.     @SuppressWarnings("unchecked")  
13.     public ListAdapter(List list) {  
14.         this.list = list;  
15.     }  
16.   
17.     public int size() {  
18.         return list.size();  
19.     }  
20.   
21.     public Object get(Object i) {  
22.         return list.get((Integer.valueOf(i.toString())).intValue());  
23.     }  
24. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public class Client {  
4.     public static void main(String[] args) {  
5.   
6.         System.out.println(Utils.getElements());  
7.         ListAdapter listadapter = new ListAdapter(Utils.getElements());  
8.         Application.print(listadapter);  
9.     }  
10. }  

这样就自然的打印处理如下内容：

[html] view plain copy

1. [first, second, third]  
2. first second third   

其旨在对于仅能操作HashMap的用户一样可以使用这个只能操作List的工具包。

使用适配器模式，可以讲一个系统的接口和本来不相容的另一个系统的类联系起来，从而使得这两个类能够一起工作，强调了对接口的转换。

这里也简单的说一下默认适配器模式：

这个么模式是大多数API接口使用的方式，以方便用户的使用，简单的定义一个接口里面有好多方法，为了不不得不的实现那么多方法，紧接着定义一个抽象类来实现这个接口，这样就可以继承抽象类来重写自己想要的方法而不写过多的没有意义的方法了。简单的例子如下：

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public interface Phone {  
4.     public void sendMessage();  
5.   
6.     public void surfInternet();  
7.   
8.     public void receiveCall();  
9.   
10.     public void AsAlarm();  
11. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public abstract class ChinaMobile implements Phone {  
4.   
5.     @Override  
6.     public void AsAlarm() {  
7.         // TODO Auto-generated method stub  
8.   
9.     }  
10.   
11.     @Override  
12.     public void receiveCall() {  
13.         // TODO Auto-generated method stub  
14.   
15.     }  
16.   
17.     @Override  
18.     public void sendMessage() {  
19.         // TODO Auto-generated method stub  
20.   
21.     }  
22.   
23.     @Override  
24.     public void surfInternet() {  
25.         // TODO Auto-generated method stub  
26.   
27.     }  
28.   
29. }  

[java] view plain copy

1. package com.designpattern.adapter;  
2.   
3. public class MyPhone extends ChinaMobile {  
4.   
5.     @Override  
6.     public void AsAlarm() {  
7.         System.out.println("I just use it as a alarm!");  
8.     }  
9.       
10.   
11. }