设计模式（六）：适配器模式

一、『适配器模式』定义

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

生活中常见场景：如果一个两脚插头想要插在三脚插座上，需要一个【适配器】充当中间的转换。这里两脚插头称作【目标接口】，三脚插座称作【被适配者】。

客户使用适配器的过程如下：

1）客户通过目标接口调用适配器的方法对适配器发出请求。

2）适配器使用被适配者接口把请求转换成被适配者的一个或多个调用接口。

3）客户接收到调用的结果，但并未察觉这一切是适配器在起转换作用。

注意：客户和适配器是解耦的，一个不知道另一个。通常是让一个适配器包装一个被适配者。

二、使用

适配器模式有两种适配器，分别是“对象”适配器和“类”适配器。

2.1 “对象”适配器

2.1.1 类图说明

“对象”适配器使用目标接口和被适配者对象。

2.1.2 场景

场景：现在，假设你缺鸭子对象，想用一些火鸡对象来冒充。显而易见，因为火鸡的接口不同，所以我们不能公然拿来用。这时就需要一个适配器！

Java代码如下：

/**
 * 鸭子接口
 */
interface Duck{
     
    public void quack();  // 呱呱叫
    public void fly();  // 飞行
}

/**
 * 绿头鸭类，实现鸭子接口
 */
class MallarDuck implements Duck{
     
    public void quack() {
     
        System.out.println("MallarDuck quack!");
    }

    public void fly() {
     
        System.out.println("MallarDuck fly!");

    }
}

/**
 * 火鸡接口
 */
interface Turkey{
     
    public void gobble();
    public void fly();
}

/**
 * 野火鸡类，实现火鸡接口
 */
class WildTurkey implements Turkey{
     
    public void gobble() {
     
        System.out.println("WildTurkey gobble!");
    }

    public void fly() {
     
        System.out.println("WildTurkey fly!");
    }
}

/**
 * 适配器，将火鸡适配成鸭子
 */
class TurkeyAdapter implements Duck{
       // Duck是目标接口
    Turkey turkey;  // 被适配对象

    public TurkeyAdapter(Turkey turkey) {
     
        this.turkey = turkey;
    }

    public void quack() {
     
        turkey.gobble();
    }

    public void fly() {
     
        turkey.fly();
    }
}

/**
 * 测试
 */
public class Demo {
     
    public static void main(String[] args) {
     
        // 鸭子对象
        Duck duck = new MallarDuck();
        duck.quack();
        duck.fly();
        // 火鸡对象
        Turkey turkey = new WildTurkey();
        turkey.gobble();
        turkey.fly();
        // 使用适配器将火鸡适配成鸭子
        TurkeyAdapter turkeyAdapter = new TurkeyAdapter(turkey);
        turkeyAdapter.quack();
        turkey.fly();
    }
}

2.2 “类”适配器

2.2.1 类图说明

“类”适配器继承目标类和被适配者类。

2.3 两者对比

1）“对象”适配器

• 使用目标接口和被适配者对象。
• 使用组合，不仅可以适配某个类，也可以配该类的任何子类。

2）“类”适配器

• 继承目标类和被适配者类。
• 不需要重新实现整个被适配者。必要的时候，也可以覆盖被适配者的行为，因为采用了继承的方式。
• “类”适配器需要多重继承才能够实现它，这在Java中是不可能的。但是在使用多重继承语言的时候，还是可能遇到这样的需求。

参考

《HeadFirst设计模式》