学步园

类适配器 
客户的开发人员定义了一个接口，期望用这个接口来完成整数的求和操作，接口定义如下： 

Java代码  

1. public interface Operation{  
2.       public int add(int a,int b);  
3. }  

开发人员在了解这个接口的定义后，发现一个第三方类，里面有一个方法能实现他们期望的功能，其代码如下： 

Java代码  

1. public class OtherOperation{  
2.       public int otherAdd(int a,int b){  
3.            return a + b;  
4.       }  
5. }  

以上第三方类OtherOperation的方法public
int otherAdd(int a,int b)所提供的功能，完全能符合客户的期望，所以只需要想办法把OtherOperation的otherAdd(int
a,int b)和客户的Operation接口联系起来，让这个第三方类来为客户提供他们期望的服务就行了，这样就避免了开发人员再度去研究类似OtherOperation的otherAdd(int
a,int b)方法的实现（利用已有的轮子，避免重复发明），这方法之一，就是用适配器模式： 

Java代码  

1. public class AdapterOperation extends OtherOperation implements Operation{  
2.       public int add(int a,int b){  
3.            return otherAdd(a,b);  
4.       }  
5. }  

以上就是适配器的实现方法之一，类适配器，在以上实现中存在着三中角色分别是： 
1：适配目标角色：Operation。 
2：适配类（原）角色：OtherOperation。 
3：适配器角色：AdapterOperation。 
其中适配器角色是适配器模式的核心。 
适配器的主要工作就是通过封装现有的功能，使他满足需要的接口。 

对象适配器 
我们再来看看另一种情况： 
假如客户接口期望的功能不止一个，而是多个： 

Java代码  

1. public interface Operation{  
2.       public int add(int a,int b);  
3.       public int minus(int a,int b);  
4.       public int multiplied(int a,int b);  
5. }  

而能提供这些实现的原可能不止一个： 

Java代码  

1. public class OtherAdd{  
2.       public int otherAdd(int a,int b){  
3.            return a + b;  
4.       }  
5. }  
6.   
7. public class OtherMinus{  
8.       public int minus(int a,int b){  
9.            return a - b;  
10.       }  
11. }  
12.   
13. public class OtherMultiplied{  
14.       public int multiplied(int a,int b){  
15.            return a * b;  
16.       }  
17. }  

由于java是不能实现多继承的，所以我们不能通过构建一个适配器，让他来继承所有原以完成我们的期望，这时候怎么办呢?只能用适配器的另一种实现--对象适配器： 

Java代码  

1. public class AdapterOperation implements Operation{  
2.       private OtherAdd add;  
3.       private OtherMinus minus;  
4.       private OtherMultiplied multiplied;  
5.   
6.       public void setAdd(OtherAdd add){  
7.             this.add = add;  
8.       }  
9.   
10.       public void setMinus(OtherMinus minus){  
11.             this.minus = minus;  
12.       }  
13.   
14.       public void setMultiplied(OtherMultiplied multiplied){  
15.             this.multiplied = multiplied;  
16.       }  
17.   
18.       //适配加法运算  
19.       public int add(int a,int b){  
20.            return add.otherAdd(a,b);  
21.       }  
22.   
23.       //适配减法运算  
24.       public int minus(int a,int b){  
25.           return minus.minus(a,b);  
26.       }  
27.   
28.       //适配乘法运算  
29.       public int multiplied(int a,int b){  
30.          return multiplied.multiplied(a,b);  
31.       }  
32. }  

上面代码很明显，适配器并不是通过继承来获取适配类（原）的功能的，而是通过适配类的对象来获取的，这就解决了java不能多继承所带来的不便了。这也是java提倡的编程思想之一，即尽量使用聚合不要使用继承。 
还有一种情况是需要使用对象适配器的。我们来看看， 
单我们的客户提供的需求并不是一个明确的接口，而是一个类，并没有定义期望的方法，如下 

Java代码  

1. public class A{  
2.    public int add(int a,int b){  
3.       return a + b;  
4.    }  
5. }  

现在客户要一个新类B，要求能在保留类A功能的情况下增加一个运算减法的功能，并要求B能随时替换掉A但不能对已有系统造成影响。这样我们只能新建一个类B，并让B继承A。 

Java代码  

1. public class B extends A{  
2.     b(){  
3.       super();  
4.     }  
5.   
6.     public int minus(int a,int b){  
7.            //待实现的减法运算函数..  
8.     }  
9. }  

这时候，我们发现类C已经提供了实现减法的函数， 

Java代码  

1. public class C{  
2.     public int minus(int a,int b){  
3.            return a - b;  
4.     }  
5. }  

为了避免重复去设计该函数，我们决定引入C类，通过适配C类来达到我们的期望，但问题是A和C都是一个具体类，我们无法让B同时继承这个两个类，而B继承A又是必须的，所以我们只能考虑把C给内聚到B内部，对象适配器又得派上用场了。 

Java代码  

1. public class B extends A{  
2.   
3.     private C c;  
4.   
5.     B(){  
6.       super();  
7.     }  
8.   
9.     public void setMinus(C c){  
10.          this.c= c;  
11.     }  
12.   
13.     public int minus(int a,int b){  
14.            return c.minus(a,b);  
15.     }  
16. }  

这样，在需要A类的地方都能用B类来代替，同时又保证了新的功能的引入。 

更灵活的实现--隐藏目标接口的抽象适配器 

做java 桌面应用的都知道WindowListener接口， 

Java代码