设计模式之适配器模式详解

适配器模式的官方定义：将一个类的接口转换为客户期望的另外的一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
目的：消除由于接口不匹配造成的类的不兼容问题。
分类：有三类，主要是类的适配器模式，对象的适配器模式，接口的适配器模式。

1.类的适配器模式

核心思想：有一个源目标类，有一个method1()方法，目标接口是Targetable接口，通过适配器Adapter类，将Source的功能扩展到目标接口中。

1.类的适配器模式：

首先是我们的源目标类：

public class Source {  

    public void method1() {  
        System.out.println("this is original method!");  
    }  
}

然后是我们的目标接口：

public interface Targetable {  

    /* 与原类中的方法相同 */  
    public void method1();  

    /* 新类的方法 */  
    public void method2();  
} 

最后就是我们的适配器：

public class Adapter extends Source implements Targetable {  

    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
} 

Adapter 继承源目标类，并且实现目标接口，下面是测试代码：

public class AdapterTest {  

    public static void main(String[] args) {  
        Targetable target = new Adapter();  
        target.method1();  
        target.method2();  
    }  
} 

输出：
this is original method!
this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能，就解决了由于接口不兼容而导致类不能一起工作的问题。

2.对象的适配器模式：

对象的适配器模式的核心思想跟类的适配器模式差不多一样，区别在于此时Adapter不继承Source类，而是拥有Source一个实例。

核心类图：

我们只是需要修改一下Adapter的代码即可：

public class Adapter implements Targetable {  
    private Source source;  

    public Wrapper(Source source){  
        super();  
        this.source = source;  
    } 
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }
    @Override  
    public void method1() {  
        source.method1();  
    }   
}

测试代码：

public class AdapterTest {  
    public static void main(String[] args) {  
        Source source = new Source();  
        Targetable target = new Wrapper(source);  

        target.method1();  
        target.method2();  
    }  
}

3.接口的适配器模式
首先我们先来看这么一个问题，就是在一个接口中我们写了很多个方法，如果我们要写该接口的实现类的时候又必须实现该接口的所有方法，但是有一些方法又不是我们所需要的，这个时候去实现完所有的方法实在是太浪费了。
这是接口的适配器模式就有很大的作用了，所谓的接口适配器模式，我们可以借助一个抽象类实现该接口，我们不去跟源接口打交道，而是用一个类去继承这个抽象类，只需要重写我们需要的方法即可。

源接口：

    public interface Sourceable {  

        public void method1();  
        public void method2();  
    }  
}

抽象类：

public abstract class Wrapper2 implements Sourceable{   
    public void method1(){}  
    public void method2(){}  
}

比如我们只是需要method1()

public class SourceSub1 extends Wrapper2 {  
    public void method1(){  
        System.out.println("the sourceable interface's first Sub1!");  
    }  
} 

比如我们只是需要method2()

public class SourceSub2 extends Wrapper2 {  
    public void method2(){  
        System.out.println("the sourceable interface's first Sub2!");  
    }  
} 

最后是测试代码：

public class WrapperTest {  

    public static void main(String[] args) {  
        Sourceable source1 = new SourceSub1();  
        Sourceable source2 = new SourceSub2();  

        source1.method1();  
        source1.method2();  
        source2.method1();  
        source2.method2();  
    }  
} 

结果：

the sourceable interface’s first Sub1!
the sourceable interface’s second Sub2!

最后我们来总结一下适配器的使用场景：

1.类的适配器模式，当一个类需要转换成满足另外一个新接口的时候，可以使用类的适配器模式，创建一个新类，继承源类，现实新的接口就可以。

2.对象的适配器模式，当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

3.接口的适配器模式，当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。