面试官老爱问适配器模式与外观模式，看看4年开发是怎么回答的吧

前言

外观模式
定义：提供了一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层接口，让子系统更容易使用。

适配器模式是将一个类的接口转换成客户希望的另外一个接口，身边很多东西都是适用于适配器模式的，笔记本的电源（也叫电源适配器），是将220V的交流电转换为笔记本电脑所需要的12V（电流先忽略），笔记本电脑的各种接口，VGA转Hdml，USB-TypeA 转 USB-TypeC,亦或者你在香港买了个手机，充电器是你生活中没见过的三孔插座通过一个转换头转换为国内常用的插头，很多例子都能很形象的解释这个设计模式。适配器模式（有时候也称包装样式或者包装）将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

定义适配器模式

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

对象和类适配器的类图

实际上有两种适配模式，"对象"适配器和"类"适配器，在Java中类适配器不能实现，因为需要多重继承的支持。

• "对象"适配器

• "类"适配器

"对象"适配器是通过使用对象的组合实现的接口转换，"类"适配器则是同时继承被适配者和目标类实现的。

实现对象适配器

先来个简单的实现，现在我有一个鸭子类，它的子类都可以呱呱叫，我想让一个咯咯叫的火鸡也拥有鸭子的行为。我们可以使用对象适配器伪装火鸡让它看起来像鸭子。

鸭子行为类：Duck接口

public interface Duck {
    void quack(); // 呱呱叫
    void fly();
}

绿头鸭是鸭子的子类：MallardDuck

// 绿头鸭
public class MallardDuck implements Duck {
    public void quack() { // 呱呱叫
        System.out.println("Quack...");
    }
    public void fly() {
        System.out.println("I'm flying 5 meters");
    }
}

火鸡行为类：Turkey接口

public interface Turkey {
    void gobble(); // 咯咯叫
    void fly();
}

野火鸡是火鸡的子类：WildTurkey

public class WildTurkey implements Turkey {
    public void gobble() { // 咯咯叫
        System.out.println("Gobble...");
    }
    public void fly() {
        System.out.println("I'm flying a 1 meter");
    }
}

接下来我们需要让火鸡伪装成鸭子，写一个适配器，让它适配火鸡

火鸡适配器类：TurkeyAdapter

public class TurkeyAdapter implements Duck {
    Turkey turkey; // 组合
    // 取得要适配的对象引用
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }
    // 接口装换
    public void quack() { // 简单的转换
        turkey.gobble();
    }
    public void fly() { // 稍微难一点的转换
        for(int i = 0; i < 5; i++)
            turkey.fly();
    }
}

测试适配器：DuckTestDriver

public class DuckTestDriver {
    public static void main(String[] args) {
        // 绿头鸭子
        Duck duck = new MallardDuck(); 
        // 野火鸡
        Turkey turkey = new WildTurkey();
        // 野火鸡使用适配器伪装成鸭子
        TurkeyAdapter turkeyAdapter = 
            new TurkeyAdapter(turkey);

        System.out.println("The Turkey says...");
        turkey.gobble();
        turkey.fly();

        System.out.println("\nThe Duck says...");
        TestDuck(duck);

        System.out.println("\nThe TurkeyAdapter says...");
        TestDuck(turkeyAdapter);
    }
    static void TestDuck(Duck duck) {
        duck.quack();
        duck.fly();
    }
}

测试结果

The Turkey says...
Gobble...
I'm flying a 1 meter

The Duck says...
Quack...
I'm flying 5 meters

The TurkeyAdapter says...
Gobble...
I'm flying a 1 meter
I'm flying a 1 meter
I'm flying a 1 meter
I'm flying a 1 meter
I'm flying a 1 meter

可见，火鸡在适配器的帮助下成功的被认为是鸭子，但是它的本质不变它还是火鸡，只能咯咯叫。

真实世界的适配器

旧世界的迭代器 和 新世界的迭代器

• 在Java早期的集合（Collection）类型（例如：Vector、Stack、HashTable这些类现在都被遗弃了）都实现了一个名为elements()方法。它会返回一个Enumeration举，跟我们现在的Iterator迭代器作用差不多，就是遍历集合，但是枚举是"只读"的，意味着它不能像迭代器那样删除元素。

面对以前的遗留代码，这些代码只暴露出枚举器的接口，但是我们希望用使用迭代器，那么我们需要构造一个适配器，让枚举器看起来像迭代器，进而使用它。

根据上例所了解的对象适配器我们先设计出类图，像这样：

编写一个EnumerationIterator适配器：

//使用了Iterator伪装的一个Enumeration
public class EnumerationIterator implements Iterator