适配器模式

结构型模式概述

    结构模式(Structural Pattern)描述的是如何组合类和对象已获得更大的结构。类模式和对象模式之间的区别是，类模式描述的是如何使用继承提供更有用的程序接口。而对象模式描述的是通过使用对象组合或将对象包含在其他对象里，将对象组合成更大的结构。
    例如，适配器模式(Adapter Pattern)可以使用一个类的接口区配另一个接口，从而是程序设计变得更容易。还会看到其他的结构模式，能将对象组合来实现新功能。例如组合模式(Composite Pattern)，正如他的名字一样对象组合，其中每个对象既可以是简单的对象也可以是组合对象。代理模式(Proxy Pattern)通常是一个简单的对象，他代替一个比较复杂的、稍后会被调用的对象，例如，当一个程序运行在一个网络环境中。享元模式(Flyweight Pattern)用于共享对象，其中的每个实例都不包含自己的状态，而将状态储存在外部，当存在大量的对象是而且他们只有几种类型是，对象可以共享节省储存空间。外观模式(Facade Pattern)用一个类表示一个子系统，桥连模式(Bridge Pattern)将对象的接口和它的实现分离，这样就可以独立改变他们。装饰模式 (Decorator Pattern)可以动态的改对象添加职责。

适配器模式(Adapter Pattern)概述

    适配器模式可以将一个类的程序设计接口转换成另外一个接口。当我们想让不相关的类在一个程序里工作时，可以用适配器模式。适配器模式的概念比较简单：编写一个具有
所需要的接口类，然后让它和拥有不同接口类进行通信。
    有两种方法实现，第一种情况里，读者从一个不一致的类里派生出一个新类，然后添加需要的方法，是新的派生类能匹配所需要的接口。另一种方式是，把原始类包含在新类里，
然后再新类里创建方法去转换调用。这两种方法分别叫做类适配器和对象适配器。

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

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

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

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)方法的实现（利用已有的轮子，避免重复发明），这方法之一，就是用适配器模式：

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

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

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 }  

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

 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 }  

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

 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提倡的编程思想之一，即尽量使用聚合不要使用继承。

　　 还有一种情况是需要使用对象适配器的。我们来看看，我们的客户提供的需求并不是一个明确的接口，而是一个类，并没有定义期望的方法，如下

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。 

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

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

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内部，对象适配器又得派上用场了。

 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 }