适配器模式--Adapter Pattern

　　模拟场景：很多人都喜欢看NBA吧，姚明进驻NBA，打开了中国的市场。虽然后面姚明在NBA打得还不错，但是在刚进入NBA篮坛的时候，并不是那么顺利的。语言交流就是一个最大的问题。刚开始打球期间，教练及队员的战术部署姚明都无法理解，所以他需要这么一个翻译者，将教练及队员的意思转达给姚明，这样才可以进行合作。

　　现在进行场景的模拟，先不考虑那么多。假如姚明一开始进入NBA的时候就已经会英语，可以进行交流了。那么这个时候教练就可以进行战术的部署了。

　　转换成类，所有的队员都要服从教练的战术要求，假设现在教练都要给队员部署进攻和防守的指令。所有大家接收的动作是一致的，只是实现不一样而已。所有这里需要先定义出一个接口或者抽象类。

IPlayer 

package com.zqz.dp.adapter;
/**
 * @author Qin 所有运动员的父接口，完成同样的动作
 */
public interface IPlayer {
    /**
     * 运动员进攻
     */
    void attack();
    /**
     * 运动员防守
     */
    void defense();
}

　　构建完接口之后，就是对接口进行实现了。假设现在有前锋forwards、中锋center、后卫guards三种运动员，来根据教练的指令完成不同的动作。

Forwards

package com.zqz.dp.adapter;
/**
 * @author Qin
 * 前锋类，实现运动员接口，实现自己的动作
 */
public class Forwards implements IPlayer {
    private String name;    //定义运动员的名字
    public Forwards(String name) {        //构造方法赋值
        this.name = name;
    }
    @Override
    public void attack() {
        System.out.println("前锋〖"+this.name+"〗攻击。。。");
    }
    @Override
    public void defense() {
        System.out.println("前锋〖"+this.name+"〗防守。。。");
    }
}

Center

package com.zqz.dp.adapter;
/**
 * @author Qin
 * 中锋类，实现运动员接口，实现自己的动作
 */
public class Center implements IPlayer {
    private String name;    //定义运动员的名字
    public Center(String name) {        //构造方法赋值
        this.name = name;
    }
    @Override
    public void attack() {
        System.out.println("中锋〖"+this.name+"〗攻击。。。");
    }
    @Override
    public void defense() {
        System.out.println("中锋〖"+this.name+"〗防守。。。");
    }
}

Guards

package com.zqz.dp.adapter;
/**
 * @author Qin
 * 后卫类，实现运动员接口，实现自己的动作
 */
public class Guards implements IPlayer {
    private String name;    //定义运动员的名字
    public Guards(String name) {        //构造方法赋值
        this.name = name;
    }
    @Override
    public void attack() {
        System.out.println("后卫〖"+this.name+"〗攻击。。。");
    }
    @Override
    public void defense() {
        System.out.println("后卫〖"+this.name+"〗防守。。。");
    }
}

Client

package com.zqz.dp.adapter;
/**
 * @author 
 * Qin 场景类，模拟NBA比赛
 */
public class Client {
    public static void main(String[] args) {
        IPlayer ba=new Forwards("巴蒂尔");
        ba.attack();
        IPlayer yao=new Center("姚明");
        yao.attack();
        yao.defense();
        IPlayer mai=new Guards("麦迪");
        mai.defense();
    }
}

　　以上的操作很简单，说白了就是父类引用指向子类实例，但是现在姚明是直接可以听懂了教练的战术安排了，这个已经是后面发展得很好的姚明了。并不是一开始不能进行交流的那个大姚了。

　　要模拟刚入NBA的大姚，那么说明需要创建一个新的类来表示大姚这个对象。在这里我们把Center改成foreignCenter，表示外籍中锋。而很明显这个时候大姚根本无法听懂教练的意思，所以需要一个翻译者translator，翻译者是可以听懂教练的意思的，但是听懂了总不能自己上场比赛吧，所以要把教练的意思传递给大姚，交给大姚去执行。

　　转化为类之间的关系也就是translator类要实现IPlayer接口，并且要有一个fireignCenter的引用，具体的实现交给引用去调用自己的方法。

ForeignCenter

package com.zqz.dp.adapter;
/**
 * @author Qin 
 * 外籍中锋类，外籍中锋是新引进的类，并不能听懂教练的意思，所以只能执行自己的功能
 */
public class ForeignCenter {
    private String name; // 定义运动员的名字
    public ForeignCenter(String name) { // 构造方法赋值
        this.name = name;
    }
    public void attack() {
        System.out.println("外籍中锋〖" + this.name + "〗攻击。。。");
    }
    public void defense() {
        System.out.println("外籍中锋〖" + this.name + "〗防守。。。");
    }
}

Translator

package com.zqz.dp.adapter;
/**
 * @author Qin
 * 翻译者类，适配器对象。传递教练的意思给外籍中锋
 */
public class Translator implements IPlayer {
    private ForeignCenter fc;
    public Translator() {    //翻译者类知道要把消息传递给谁，所以立即生成外籍中锋实例
        fc=new ForeignCenter("大姚");
    }
    @Override
    public void attack() {
        this.fc.attack();    //告诉大姚要进行攻击
    }
    @Override
    public void defense() {
        this.fc.defense();    //告诉大姚进行防守
    }
}

　　其他类不变。这样就完成了功能，由翻译者转达大姚进行战术的安排。

　　上面的操作其实很简单，只是在执行的时候调用的是具体真实类的操作而已。是否会觉得有点跟代理类似，其实会这样觉得是因为我把ForeignCenter中的方法定义成和IPlayer的方法一致。也就是说虽然教练给大姚下达了战术的安排，但是大姚可以执意按自己的想法进行安排。所以这也是和代理不同的地方。

　　以上的操作就是适配器模式，准确来说是对象适配器，因为在类中传递了另一个类的引用。还有另一种叫做类适配器。要实现类适配器就方便多了，只要让Translator继承ForeignCenter即可，再调用父类的方法。很明显在这里是不合适的，因为两者不存在is-a的关系，所以在真正开发中，对象适配器用的必类适配器多。

　　听名字大家就应该能明白意思了，何为适配器？就是把两个不合适的对象通过一个中间对象连接起来。像我们平常的电池充电不也需要一个电源适配器吗？就是一样的道理。

　　适配器模式是一个补救的模式，也就是说一般在开发前期不会考虑该模式，而是在后期扩展中才会考虑到。还是以上面的例子为例，NBA事先根本就不能料想到是否会有中国球员参加比赛，所以才会有翻译者的存在，翻译者就是一个适配器。

适配模式的优点：

　　1、  适配器可以将两个毫无关联的对象连接起来。

　　2、  增加了类的透明度：也就是说教练根本不用管大姚，直接告诉翻译者如何做就行了。

　　3、  提高了类的复用性，易扩展，灵活性好。

适配器的使用场景：

　　你有动机去修改一个已经投入生产的接口时，就可以使用适配器进行扩展。

适配器的拓展：

　　除了类适配器和对象适配器外，还有一种缺省适配器，所谓的缺省适配器就是说在一个接口中存在了一大堆的方法，但是我们在具体的实现中根本就不需要这么多方法，那么我们就可以创建一个中间类，把这些方法全部空实现，然后具体的类再继承该空实现的类，完成自己所需要的功能。