适配器模式

把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

问题引出：大家生活中可能碰到的一个问题就是你新买的手机自带的耳机是2.5接口的，不幸的是有一天你的耳机坏了，你去市面上根本就找不到2.5的耳机了，基本上是3.5接口了，没办法你只好买了个3.5接口的耳机，老板告诉你：“我给你一个适配器”这不问题就解决了。

问题分析：3.5的接口的耳机在你手机上本来是没法使用的，因为它没有按照2.5接口的设计啊，而现在我又想使用这幅耳机，于是乎有了“适配器（Adapter）”这个一个东西出来了。

Adapter模式的定义：把一个类的接口变换成客户端所期待的另外一种接口，使得原本由于接口不兼容而不能再一起工作的那些类可以一起工作。

适配器模式分类：1.类的适配器模式（采用继承实现）2.对象适配器（采用对象组合方式实现）

类的适配器类图：

模式的构成：以问题中例子为模型

目标抽象角色(Target):定义客户所期待要使用的接口，我们把手机当做客户端，客户端所需要使用的耳机的接口是2.5的，在这里就可以抽象出来一个2.5接口的设备（并不一定是耳机）。

源角色(Adaptee):需要被适配的接口，在这里指的是我们从市场上买回来的那个3.5接口的耳机。

适配器角色(Adapter)：用来把源接口转换成符合要求的目标接口的设备，在这里指的是老板送给我们的那个“转换器”。

客户端(Client)：这里指的就是那个给我们带来麻烦的手机喽。

示例代码：

Java代码   

1. //Target  
2.   
3. package pattern.adapter;  
4.   
5. public interface Target {  
6.   
7.     public void provide2_5();  
8.   
9. }  
10.   
11. //Adaptee  
12.   
13. package pattern.adapter;  
14.   
15. public class Adaptee {  
16.   
17.     public void provide3_5(){  
18.   
19.        System.out.println("我是一个3.5的接口哦");  
20.   
21.     }  
22.   
23. }  
24.   
25. //Adapter  
26.   
27. package pattern.adapter;  
28.   
29. public class Adapter extends Adaptee implements Target {  
30.   
31.     @Override  
32.   
33.     public void provide2_5() {  
34.   
35.        this.provide3_5();  
36.   
37.     }  
38.   
39. }  
40.   
41. //Client  
42.   
43. package pattern.adapter;  
44.   
45. public class CellPhoneClient {  
46.   
47.     public static void main(String[] args) {  
48.   
49.        Target target = new Adapter();  
50.   
51.        //该手机只支持2.5接口的耳机  
52.   
53.        target.provide2_5();  
54.   
55.     }  
56.   
57. }  

 输出结果

：我是一个3.5的接口哦

从输出结果可以看出只支持2.5接口的手机成功的使用3.5的耳机了。这就是适配器模式的作用。

对象的适配器模式：

对象的适配器模式的不同之处在于Adapter角色封装了Adaptee角色，而不像类的适配器模式所采取的继承方式。其原理基本上是相似的。

有时我们定义的接口中多个接口方法，如果直接实现此接口，那么需要在实现类中实现所有的方法，往往不同的需要，可能只用到接口中一个会几个方法，但显然用这样的实现类会造成资源的浪费，系统开销的加大。那么如何解决此问题，用是配给模式。

适配器模式的的核心思想是：为原接口类实现一个默认的抽象类，在改抽象类中编写每一个放的默认实现，当我们需要编写一个具体类事，只需要继承该抽象类，而不需要实现原有的接口，并且不需要所有的接口方法，只实现需要的函数即可。下面看代码：

源接口：Sourceable

public interface Sourceable {

    public void operation1();

    public void operation2();

}

抽象类:DefaultWrapper,此类实现类接口Sourceable，并提供了两个接口函数的实现，在该实现中什么也不做，目的只是为了给其子类提供一个默认的实现，如下

public abstract class DefaultWrapper implements Sourceable {

   public void operation1(){}

   public void operation2(){}

}

子类继承自DefaultWrapper，只需实现自己想实现函数，之所以能这样是由于抽象类DefaultWrapper的屏蔽作用，代码如下

public class SourceSub1 extends DefaultWrapper {

    public void operation1(){

        System.out.println("hi,run the method operation1 of SourceSub1 ");

   }

}

public class SourceSub2 extends DefaultWrapper {

    public void operation2(){

        System.out.println("hi,run the method operation2 of SourceSub2");

   }

}

下面编写测试类DefaultWrapper,常见两个对象，然后调用方法operation1,operation2。代码如下

public class DefaultWrapperTest {

    public static void main(String[] args) {

         Sourcable1 source1 = new SourceSub1();

         Sourcable2 source2 = new SourceSub2();

         source1.operation1();

         source1.operation2();

         System.out.println("--------------------------------------------");

          source2.operation1();

         source2.operation2();

    }

}

运行该程序的结果如下:

hi,run the method operation1 of SourceSub1

--------------------------------------------

hi,run the method operation2 of SourceSub2