JAVA设计模式详解（五）----------适配器模式

　各位朋友好，本章节我们继续讲第五个设计模式。　

　　在生活中，我们都知道手机内存卡是无法直接接电脑的，因为内存卡的卡槽比较小，而电脑只有USB插孔，此时我们需要用到读卡器。这个读卡器就相当于是适配器。这是生活上的适配器，那么在OO对象中，适配器就是将一个接口转换成另一个接口，使得客户可以使用。

适配器模式从实现方式上分为两种，类适配器和对象适配器，这两种的区别在于实现方式上的不同，一种采用继承，一种采用组合的方式。

下面我们来看一个例子，下面有两个接口，一个是鹿(Deer)，一个是狼(wolf)，

public interface Deer {
    public void run();
    public void eatGrass();
}

interface Wolf{
    public void run();
    public void eatMeat();
}

我们让梅花鹿(SikaDeer)和雪狼(SnowWolf)分别实现这两个接口

class SikaDeer implements Deer{

    @Override
    public void run() {
        System.out.println("我在跑");

    }

    @Override
    public void eatGrass() {
        System.out.println("我在吃草");

    }

}

class SnowWolf implements Wolf{

    @Override
    public void run() {
        System.out.println("我在跑");

    }

    @Override
    public void eatMeat() {
        System.out.println("我在吃肉");

    }

}

假设现在狼要吃鹿，但是他要伪装成鹿然后混进去，那么现在因为接口不同，无法伪装，所以现在我们帮它写个适配器：

class  SnowAdapter implements Deer{//首先我们需要实现想转换成的接口，也就是鹿要看到的接口
    private SnowWolf snowWolf;
    public SnowAdapter(SnowWolf snowWolf) {
        this.snowWolf = snowWolf;//接着取得我们要适配的对象的引用
    }
    @Override
    public void run() {
        snowWolf.run();//接着实现接口的方法

    }

    @Override
    public void eatGrass() {
        snowWolf.eatMeat();

    }
}

接下来我们写个测试类：

public class TestAdapter {
    public static void main(String[] args) {
        Deer sikaDeer = new SikaDeer();//先来个梅花鹿
        SnowWolf snowWolf = new SnowWolf();//再来个雪狼
        SnowAdapter snowAdapter = new SnowAdapter(snowWolf);//接下来是伪装后的雪狼
        System.out.println("snowWolf:");
        snowWolf.run();
        snowWolf.eatMeat();

        System.out.println("sikaDeer says:");
        testDeer(sikaDeer);

        System.out.println("snowAdapter says:");
        testDeer(snowAdapter);
    }

    public static void testDeer(Deer deer){
        deer.run();
        deer.eatGrass();
    }
}

结果展示：

在这里，我们来分析一下这个过程，鹿是我们的目标接口，梅花鹿是依据鹿实现的，而适配器实现了目标接口，并持有被适配者(雪狼)的实例。

适配器模式讲一个类的接口，转换成客户期望的另一个。适配器让原本接口不兼容的类可以合作无间。

下面我们看一下类图：

这种实现方式是对象适配器，接下来LZ说一下类适配器

从类图中可以看出，客户想要的是sampleOperation2()方法，但是Adaptee并没有，为了使客户能够使用Adaptee类的sampleOperation2()方法，我们需要提供一个构造器Adapter，把Adaptee的API与Target类的API衔接起来。Adapter与Adaptee是继承关系。

这里所涉及的角色有：

　　●　　目标(Target)角色：这就是所期待得到的接口。注意：由于这里讨论的是类适配器模式，因此目标不可以是类。

　　●　　源(Adapee)角色：现在需要适配的接口。

　　●　　适配器(Adaper)角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。显然，这一角色不可以是接口，而必须是具体类。

我们用代码简单的模仿一下类图的关系，首先是目标角色

public interface Target {
    /**
     * 这是源类Adaptee也有的方法
     */
    public void sampleOperation1();
    /**
     * 这是源类Adapteee没有的方法
     */
    public void sampleOperation2();
}

接着是源，

public class Adaptee {

    public void sampleOperation1(){}

}

接下来我们写适配器，我们让适配器直接继承源，并实现目标接口，然后补充sampleOperation2()方法

public class Adapter extends Adaptee implements Target {

    @Override
    public void sampleOperation2() {
        //写相关的代码
    }

}

类适配器所用的是继承，但是因为JAVA单继承的原因，一个JAVA类只能有一个父类，所以当我们要适配的对象是两个类的时候，我们就无可奈何了。

接下来我们看一下类适配器与对象适配器之间的不同：

①类适配器使用对象继承的方式，是静态的定义方式；而对象适配器使用对象组合的方式，是动态组合的方式。

②对于类适配器，由于适配器直接继承了Adaptee，使得适配器不能和Adaptee的子类一起工作，因为继承是静态的关系，当适配器继承了Adaptee后，就不可能再去处理  Adaptee的子类了。而对于对象适配器，一个适配器可以把多种不同的源适配到同一个目标。换言之，同一个适配器可以把源类和它的子类都适配到目标接口。因为对象适配器采用的是对象组合的关系，只要对象类型正确，是不是子类都无所谓。

③  对于类适配器，适配器可以重定义Adaptee的部分行为，相当于子类覆盖父类的部分实现方法。而对于对象适配器，要重定义Adaptee的行为比较困难，这种情况下，需要定义Adaptee的子类来实现重定义，然后让适配器组合子类。虽然重定义Adaptee的行为比较困难，但是想要增加一些新的行为则方便的很，而且新增加的行为可同时适用于所有的源。

④对于类适配器，仅仅引入了一个对象，并不需要额外的引用来间接得到Adaptee。而 对于对象适配器，需要额外的引用来间接得到Adaptee。

那么到底是多用组合还是多用继承，相信大家经过了前面四章的学习，已经非常明了了。LZ建议尽量使用对象适配器的实现方式，多用合成/聚合、少用继承。不过说到底，具体问题还要进行具体分析才对，根据需要来选用实现方式，最适合的才是最好的。

适配器模式的优点

• 　　更好的复用性

　　系统需要使用现有的类，而此类的接口不符合系统的需要。那么通过适配器模式就可以让这些功能得到更好的复用。

• 　　更好的扩展性

　　在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。

适配器模式的缺点

　　过多的使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构

上面LZ说过适配器从实现方式上分为两种，类适配器和对象适配器，其实从使用目的上来说，也可以分为两种，特殊适配器和缺省适配器，这两种的区别在于使用目的上的不同，一种为了复用原有的代码并适配当前的接口，一种为了提供缺省的实现，避免子类需要实现不该实现的方法。

而我们以上两种方式都是为了复用现有的代码而采用的适配器模式，属于特殊适配器，可称为定制适配器，还有另外一种称为缺省适配器。

下面LZ举一个简单的例子：

interface Teacher{
    void speak();
    void listen();
    void teach();
}

这是一个老师的接口，张老师要实现它，但是几年前，张老师还只是一个学生，并不会teach()，所以我们需要写一个缺省适配器

abstract class Adapter implements  Teacher{

    @Override
    public void speak() {}

    @Override
    public void listen() {}

    @Override
    public void teach() {}

}

然后让张老师继承它

class ZhangTeacher extends  Adapter{
    @Override
    public void speak() {
        System.out.println("speak");
    }

    @Override
    public void listen() {
        System.out.println("listen");
    }
}

　　虽然这只是一个例子，但是在很多情况下，我们必须让一个具体类实现某一个接口，但是这个类又用不到接口所规定的所有的方法。通常的处理方法是，这个具体类要实现所有的方法，那些有用的方法要有实现，那些没有用的方法也要有空的实现。

　　这些空的方法是一种浪费，有时也是一种混乱。除非看过这些空方法的代码，否则程序员可能会以为这些方法不是空的。即便他知道其中有一些方法是空的，也不一定知道哪些方法是空的，哪些方法不是空的，除非看过这些方法的源代码或是文档。

　　而缺省适配模式可以很好的处理这一情况。可以设计一个抽象的适配器类实现接口，此抽象类要给接口所要求的每一种方法都提供一个空的方法,使它的具体子类免于被迫实现空的方法。

在任何时候，如果我们不准备实现一个接口的所有方法时，就可以使用“缺省适配模式”制造一个抽象类，给出所有方法的具体实现。这样，从这个抽象类再继承下去的子类就不必实现所有的方法了。

这一章讲完，适配器模式相信各位也有了一定的了解，此模式其实就是一种补救措施，在开发的时候，尽量不要用到这个模式。

好了，本次LZ的技术分享就到此结束了，下期分享：状态模式