《Head First 设计模式》笔记7

适配器模式（Adapter）

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

栗子

欧洲的插座大多是三脚的，而美国的插头大多是两脚的，那么如何让两脚插头插进三脚插座里呢？这就需要一个转换头，作为一个中介，二脚插头先插入转换头，然后转换头再插入三脚插座。

还记得笔记1里的鸭子吧？

interface Duck {
    void quack();

    void fly();
}

绿头鸭：

class MallardDuck implements Duck {
    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }

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

现在有一个火鸡的接口：

interface Turkey {
    void gobble(); // 火鸡是咯咯叫

    void fly(); // 会飞，但是飞不远
}

野生火鸡：

class WildTurkey implements Turkey {
    @Override
    public void gobble() {
        System.out.println("咯咯叫");
    }

    @Override
    public void fly() {
        System.out.println("飞很短的距离");
    }
}

需求来了：你的鸭子不够卖了，想拿火鸡来冒充鸭子。

需求分析

很明显，火鸡和鸭子的叫声接口不同，而且又不能长途飞，客人肯定会发现的，怎么骗过他们呢？那就需要使用到适配器，让火鸡“变成”鸭子了。（只是形式上的调用欺骗）

满足需求

把火鸡变成鸭子的适配器：

class TurkeyAdapter implements Duck {
    Turkey turkey;

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

    // 原来的咯咯叫变成了呱呱叫
    @Override
    public void quack() {
        turkey.gobble();
    }

    // 火鸡飞的太短，要多飞几次才像鸭子
    @Override
    public void fly() {
        for (int i = 0; i < 5; i++) {
            turkey.fly();
        }
    }
}

测试

public static void main(String[] args) {
    MallardDuck duck = new MallardDuck();
    WildTurkey turkey = new WildTurkey();
    Duck turkeyAdapter = new TurkeyAdapter(turkey);

    System.out.print("火鸡：");
    turkey.gobble();
    turkey.fly();

    System.out.print("鸭子：");
    testDuck(duck);

    System.out.print("冒充鸭子的火鸡：");
    testDuck(turkeyAdapter);
}

public void testDuck(Duck duck) {
    duck.quack();
    duck.fly();
}

真实世界的适配器

是不是感觉上面的鸭子栗子有点莫名其妙？那就看下真实世界的一个简单的适配器吧。

旧世界的枚举器

早期的集合（collection）类型（比如 Vector、Stack、Hashtable）都实现了一个名为 elements 的方法，它会返回一个 Enumeration（举）。这个接口可以遍历集合中的每个元素，而无需知道它们在集合内是如何被管理的。

interface Enumeration {
    // 是否还有元素
    boolean hasMoreElements();

    // 下一个元素
    Object nextElement();
}

新世界的迭代器

新的集合类，使用了迭代器（Iterator），和上面的枚举接口很像，但多了删除元素的功能。

interface Iterator {
    // 是否还有元素
    boolean hasNext();

    // 下一个元素
    Object next();

    // 删除元素
    void remove();
}

遗留代码

以前的代码大多都使用了枚举器，而现在系统的 Java 版本升级了，新的代码都使用了迭代器，如何兼顾新旧代码呢？这就需要我们构造一个适配器，让旧的枚举器适配到新的迭代器。

改造前

枚举里面没有 remove 方法，怎么办？我们可以直接抛出不支持该方法的异常（UnsupportedOperationException）。而其他两个方法两者都差不多，很容易适配。

改造后

class EnumerationIterator implements Iterator {
    Enumeration enum;

    public EnumerationIterator (Enumeration enum) {
        this.enum = enum;
    }

    public boolean hasNext() {
        return enum.hasMoreElements();
    }

    public boolean next() {
        return enum.nextElement();
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}

外观模式（Facade）

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

设计原则：“最少知识”，只和你的密友谈话。

上面的原则是什么意思呢？ => 不要让太多类耦合在一起，免得修改系统中的一部分，会影响到其他部分。如果许多类之间相互依赖，那么这个系统就会变成一个易碎的系统，而且太复杂也不容易被其他人理解。

像下面这样的代码就有点耦合了：

public float getTemp() {
    return station.getThermometer().getTemperature();
}