《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();
}