设计模式学习之路 - 适配器模式 - 接口转换器

今天了解一下适配器模式。

首先， 看下需求（简单的扯一下）。

农场有许多鸭子， 但是某天鸭子的数量不够，正好，农场还有些火鸡， 农场主打算用火鸡充当鸭子。。

鸭子的接口很简单，就两个方法，一个呱呱叫， 一个飞。

package com.chris.adapter;

public interface Duck {
	public void quack();
	public void fly();
}

火鸡的接口也很简单，也有两个方法， 一个咯咯叫， 一个飞（虽然会飞，但是太胖，飞的距离好短。。）

package com.chris.adapter;

public interface Turkey {
	public void gobble();
	public void fly();
}

然后，我们把农场的鸭子具体化，一种叫绿头鸭的。。

package com.chris.adapter;

public class MallardDuck implements Duck {

	@Override
	public void quack() {
		System.out.println("Quack");
	}

	@Override
	public void fly() {
		System.out.println("I'm flying");
	}

}

他实现了鸭子接口，并有了具体的行为，比如叫唤，飞！

同样， 火鸡也有某个种类。。

package com.chris.adapter;

public class WildTurkey implements Turkey{

	@Override
	public void gobble() {
		System.out.println("Gobble gobble");
	}

	@Override
	public void fly() {
		System.out.println("I'm flying a short distance");
	}
	
}

他实现了火鸡接口的两个方法， 咯咯叫以及飞很短的距离。

从接口可以看出，虽然都有两个方法， 但是方法却不一样， 这样的话， 火鸡就很难伪装成鸭子了。

所以，我们引进了适配器模式，适配器大家都知道，就是一个转换插头，比如两孔的转成三孔的，或者是国内标准的转成国外的三角方插那种（出国没有转换头很难受的，记得一定要带，手机没电不能忍。）

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

通过适配器模式，我们可以通过将需要改变的接口进行封装， 让客户从实现的接口中解耦。

比如，我们这边建一个火鸡适配器的类，实现鸭子的接口。

package com.chris.adapter;

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

}

通过将火鸡类进行包装， 将他的实现转换为需要实现的接口的模式，这样，他就是一个客户需要的接口的类了。。

我们来做下简单的测试。

package com.chris.adapter;

public class DuckTestDrive {
	public static void main(String[] args) {
		MallardDuck duck = new MallardDuck();
		WildTurkey turkey = new WildTurkey();
		Duck 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 Duck says...");
		testDuck(turkeyAdapter);
	}

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

下面贴一下测试结果（其实不贴的话，应该也猜得到结果了。。）

The Turkey says...
Gobble gobble
I'm flying a short distance

The Duck says...
Quack
I'm flying

The Duck says...
Gobble gobble
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance
I'm flying a short distance

都是两种都是“鸭子”，但是具体的实现却不一样，这样就完成了对期望转变的接口的封装。

适配器模式充满了良好的OO设计原则：使用对象组合， 以修改的接口包装被适配者，将客户和接口绑定起来，而不是具体的实现，也是一个值得遵循的地方。

实际上，适配器还可以细分为对象适配器和类适配器， 他们的区别就是，对象适配器是用的组合的方式，而类适配器是用的继承， 但是由于java是不能多继承的，所以类适配器不适用的， 一般关注对象适配器就行了。

在平时的开发过程中， 适配器的用法还是不多的。

如果在单元测试中，需要调用到第三方的类，但是又需要绕过他的调用的时候，往往可以用适配器模式对他进行包装， 用stub进行单元测试， 避免了第三方的调用的耗时。

在一个新的项目开始的时候，适配器模式几乎就不怎么用了，而是在后续进行重构或者维护的时候，为了避免对代码的大改，可以巧妙的多用适配器模式，对类进行包装，从而优雅的完成重构。

书中的例子都是Head First设计模式中（我要安利一下这本书，很好！！）的，但是都是我手敲的（没有功劳也有苦劳），如果在文中有什么错误的理解或者遗漏，还希望大家多多指导，共勉！！