开发之路（设计模式七：适配器模式）

摘要：你眼中的适配器是什么样子的呢在设计模式中也有模式叫适配器模式，一起来看看吧。定义适配器模式将一个类的接口，转换成客户期待的另一个接口。

你眼中的适配器是什么样子的呢？在设计模式中也有模式叫适配器模式，一起来看看吧。         

适配器是什么这不需要作者我多解释把，打个比方，在国内用的是220V的电器，但国外有些国家是110V甚至240V的也有等等，国内的充电线就不能直接插国外的插座了，这时候就需要一个适配器做电源转换，是的，在设计模式中也有这么一个模式与其类似，也是个很有用的模式。

下面我做了几个配图来理解设计模式。

假设已有一个系统，此时它需要更新，你希望它能和新的厂商类库搭配使用，但是这个新厂商设计出来的接口，与原系统的接口不一样。所以两者不能直接匹配。

若重构原来的代码可能会非常麻烦，而且又不能去改变厂商的代码，怎么办呢？这是你可以写一个类，将新厂商接口转换为你所期待的接口。

那么这个适配器就好比一个中间人，它将客户所发送的请求转换成厂商类能够理解的请求。

直接放一个例子，假如一只火鸡想要“冒充”成鸭子怎么做呢？
代码如下：

这是鸭子接口

package duck_Interface;

/**
 * 适配器模式：就好比在中国的电器若要在美国的插座上使用，就必须使用适配器， 
 * 适配器就相当于一个中间层，将两个原本不能相互沟通的东西连接在一起
 * 
 * @author Joy
 * 
 */
public interface Duck {
    public void quack();

    public void fly();
}

绿头鸭是鸭子的子类

package duck_Implements;

import duck_Interface.Duck;

public class MallardDuck implements Duck {
    /**
     * 绿头鸭
     */
    @Override
    public void quack() {
        System.out.println("绿头鸭叫：呱呱呱");

    }

    @Override
    public void fly() {
        System.out.println("我在飞");
    }
}

这是一只火鸡（接口）

package duck_Interface;

/**
 * 火鸡接口
 * 
 * @author Joy
 * 
 */
public interface Turkey {
    // 火鸡只会咯咯咯叫
    public void gobble();

    // 火鸡会飞，但飞不远
    public void fly();
}

这是火鸡的一个具体实现

package duck_Implements;

import duck_Interface.Turkey;

public class WildTurkey implements Turkey {
    /**
     * 火鸡类的实现
     */

    @Override
    public void gobble() {
        System.out.println("火鸡叫：咯咯咯");
    }

    @Override
    public void fly() {
        System.out.println("我会飞，但飞不高");
    }
}

很显然两者一开始不能直接匹配，这里写一个火鸡适配器

package Adapter;

import duck_Interface.Duck;
import duck_Interface.Turkey;

/**
 * 火鸡的适配器
 * 
 * @author Joy
 * 
 */
// 先要实现想要转换的类型接口，（火鸡希望和绿头鸭交流）
// 火鸡：被适配者，鸭子：适配者
// 这里火鸡要实现鸭子接口
public class TurkeyAdapter implements Duck {
    Turkey turkey;

    // 需要取得适配的对象引用
    // 利用构造器取得这个引用
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    @Override
    public void quack() {
        // 现在我们需要实现火鸡里的叫的方法
        // 很简单只需直接引用
        turkey.gobble();
    }

    /**
     * 这里由于火鸡的飞行距离短，鸭子飞行距离长， 为两者飞行能够对应， 这里得多次调用火鸡飞行方法，相当于火鸡5次飞行的距离等于一次鸭子飞行的距离。。
     */
    @Override
    public void fly() {
        for (int i = 0; i < 5; i++) {
            turkey.fly();
        }
    }
}

测试类

package TestMain;

import Adapter.TurkeyAdapter;
import duck_Implements.MallardDuck;
import duck_Implements.WildTurkey;
import duck_Interface.Duck;

public class DuckTestDrive {
    // 取得一只鸭子
    public static void testDuck(Duck duck) {
        duck.quack();
        duck.fly();
    }

    public static void main(String[] args) {
        // 创建好一只鸭子和火鸡
        MallardDuck duck = new MallardDuck();
        WildTurkey turkey = new WildTurkey();
        // 然后将火鸡“包装”进火鸡适配器中，让它看上起像只鸭子
        Duck turkeyAdapter = new TurkeyAdapter(turkey);
        System.out.println("这只火鸡说~~~~~");
        turkey.gobble();
        turkey.fly();
        System.out.println("
这只鸭子说a~~~~~");
        testDuck(duck);
        // 试着传入一个假装是鸭子的火鸡对象
        System.out.println("
火鸡适配器说~~~~~");
        /**
         * testDuck()方法不知道这是一只假装鸭子的火鸡 turkey调用叫的方法是“咯咯咯”
         * 而fly方法调用了5次，就为了让火鸡假装成鸭子一样飞的远
         */
        testDuck(turkeyAdapter);

    }
}

效果图

TurkeyAdapter里的quack方法被调用，适配器咯咯咯的叫，然后fly方法被调用，适配器执行了5次飞行操作，而在testDuck（Duck duck）它还以为参数duck真的是一鸭子，其实是只假装鸭子的火鸡（turkeyAdapter）。

让我们再看看各部分之间的关系。

客户使用适配器的过程如下：
1、客户通过目标接口调用适配器的方法对适配器发出请求。
2、适配器（鸭子）使用被适配器（火鸡）接口把请求转换成被适配器的一个或多个调用接口。
3、客户接收到调用的结果，但并未察觉这一切是适配器再起转换作用。

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

注：细分适配器类型是有两种的，对象适配器和类适配器，前面的火鸡例子是对象适配器，而“类”适配器则需要多重继承才能实现，而Java中是不被允许的，这里就不讲述。

感谢你看到这里，适配器模式到这里就结束了，本人文笔随便，若有不足或错误之处望给予指点，90度弯腰~~~很快我会发布下一个设计模式的内容，生命不息，编程不止！

参考书籍：《Head First 设计模式》