设计模式入门学习之适配器模式

转自：http://chat.iteye.com/blog/159671

还记得策略模式里面讲的鸭子吗?让我们来看看鸭子接口和类的一个简化版本:

Java代码

1. //鸭子具有呱呱叫和飞的能力
2. publicinterfaceDuck{
3. publicvoidquack();
4. publicvoidfly();
5. }
6. //绿头鸭是鸭子的子类
7. publicclassMallardDuckimplementsDuck{
8. publicvoidquack(){
9. System.out.println("Quack");
10. }
11. publicvoidfly(){
12. System.out.println("I'mflying");
13. }
14. }
15. //介绍一个新的飞禽:火鸡
16. publicinterfaceTurkey{
17. publicvoidgobble();//火鸡不会呱呱叫,只会咯咯叫
18. publicvoidfly();//火鸡会飞,但是飞不远
19. }
20. //这是火鸡的具体实现
21. publicclassWildTurkeyimplementsTurkey{
22. publicvoidgobble(){
23. System.out.println("Gobblegobble");
24. }
25. publicvoidfly(){
26. System.out.println("I'mflyingashortdistance");
27. }
28. }

//鸭子具有呱呱叫和飞的能力
public interface Duck {
	public void quack();
	public void fly();
}
//绿头鸭是鸭子的子类
public class MallardDuck implements Duck {
	public void quack() {
		System.out.println("Quack");
	}
	public void fly() {
		System.out.println("I'm flying");
	}
}
//介绍一个新的飞禽:火鸡
public interface Turkey {
	public void gobble();	//火鸡不会呱呱叫,只会咯咯叫
	public void fly();	//火鸡会飞,但是飞不远
}
//这是火鸡的具体实现
public class WildTurkey implements Turkey {
	public void gobble() {
		System.out.println("Gobble gobble");
	}
	public void fly() {
		System.out.println("I'm flying a short distance");
	}
}

现在,假设你缺少鸭子对象,想用火鸡来冒充,显而易见,因为火鸡的接口不同,所以不能公然拿来用,那么写个适配器吧:

Java代码

1. /**
2. *首先需要实现想转换成的类型接口,也就是客户所期望看到的接口
3. */
4. publicclassTurkeyAdapterimplementsDuck{
5. Turkeyturkey;
6. //这里我们利用构造器去得要适配的对象引用
7. publicTurkeyAdapter(Turkeyturkey){
8. this.turkey=turkey;
9. }
10. //现在我们需要实现接口中的所有方法,这个转换很简单,只要调用gobble()就行了
11. publicvoidquack(){
12. turkey.gobble();
13. }
14. //虽然2个接口都具备fly()方法,火鸡的飞行距离很短,不像鸭子可以长途飞行,
15. //要让火鸡与鸭子的飞行能够对应,我们连续调用5次火鸡的fly()方法
16. publicvoidfly(){
17. for(inti=0;i<5;i++){
18. turkey.fly();
19. }
20. }
21. }
22. //我们再来测试一下这个适配器
23. publicclassDuckTestDrive{
24. publicstaticvoidmain(String[]args){
25. MallardDuckduck=newMallardDuck();//先创建一只鸭子
26. WildTurkeyturkey=newWildTurkey();//再创建一只火鸡
27. //然后将火鸡包装进一个火鸡适配器中,使它看起来像一只鸭子
28. DuckturkeyAdapter=newTurkeyAdapter(turkey);
29. //先测试这只火鸡,让它咯咯叫,再让它飞行
30. System.out.println("TheTurkeysays...");
31. turkey.gobble();
32. turkey.fly();
33. //测试鸭子
34. System.out.println("\nTheDucksays...");
35. testDuck(duck);
36. //重要的地方:试着传入一个加装是鸭子的火鸡
37. System.out.println("\nTheTurkeyAdaptersays...");
38. testDuck(turkeyAdapter);
39. }
40. staticvoidtestDuck(Duckduck){
41. duck.quack();
42. duck.fly();
43. }
44. }

/**
*	首先需要实现想转换成的类型接口,也就是客户所期望看到的接口
*/
public class TurkeyAdapter implements Duck {
	Turkey turkey;
	//这里我们利用构造器去得要适配的对象引用
	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}
	//现在我们需要实现接口中的所有方法,这个转换很简单,只要调用gobble()就行了
	public void quack() {
		turkey.gobble();
	}
	//虽然2个接口都具备fly()方法,火鸡的飞行距离很短,不像鸭子可以长途飞行,
	//要让火鸡与鸭子的飞行能够对应,我们连续调用5次火鸡的fly()方法
	public void fly() {
		for(int i=0; i < 5; i++) {
			turkey.fly();
		}
	}
}
//我们再来测试一下这个适配器
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 TurkeyAdapter says...");
		testDuck(turkeyAdapter);
	}
	static void testDuck(Duck duck) {
		duck.quack();
		duck.fly();
	}
}

看看运行结果,你明白这种做法了吗?
适配器模式将一个类的接口,转换成客户期望的另一个接口.适配器让原本接口不兼容的类可以合作无间.
我们再来看看真实世界中的一个简单适配器:
1.如果你使用过java,可能记得早期的集合(collection)类型都实现了一个elements()的方法,该方法返回一个Enumeration(枚举)
2.当Sun推出更新后的集合类时,开始使用Iterator迭代器接口,这个接口比枚举多了个删除元素的能力
3.这时我们面对的遗留代码中暴露出了枚举接口,但我们又希望在新的代码中使用迭代器,这里我们就需要一个适配器了
我们先来看看这2个接口,
<<interface>>Iterator: hasNext()/next()/remove()
<<interface>>Enumeration:hasMoreElements()/nextElement()
再来设计一个适配器:

Java代码

1. publicclassEnumerationIteratorimplementsIterator{//适配器看起来就是一个Iterator
2. //我们使用组合的方式,将枚举结合进适配器中,用实例变量记录
3. Enumerationenumeration;
4. publicEnumerationIterator(Enumerationenumeration){
5. this.enumeration=enumeration;
6. }
7. //迭代器的hasNext其实是委托给enumeration的hasMoreElements方法
8. publicbooleanhasNext(){
9. returnenumeration.hasMoreElements();
10. }
11. //迭代器的next其实是委托给enumeration的nextElement方法
12. publicObjectnext(){
13. returnenumeration.nextElement();
14. }
15. //很不幸,我们不能支持迭代器的remove方法,所以必须放弃,这里是抛出一个异常
16. publicvoidremove(){
17. thrownewUnsupportedOperationException();
18. }
19. }

public class EnumerationIterator implements Iterator {	//适配器看起来就是一个Iterator
	//我们使用组合的方式,将枚举结合进适配器中,用实例变量记录
	Enumeration enumeration;
	public EnumerationIterator(Enumeration enumeration) {
		this.enumeration = enumeration;
	}
	//迭代器的hasNext其实是委托给enumeration的hasMoreElements方法
	public boolean hasNext() {
		return enumeration.hasMoreElements();
	}
	//迭代器的next其实是委托给enumeration的nextElement方法
	public Object next() {
		return enumeration.nextElement();
	}
	//很不幸,我们不能支持迭代器的remove方法,所以必须放弃,这里是抛出一个异常
	public void remove() {
		throw new UnsupportedOperationException();
	}
}

是不是了解适配器模式了?再想想适配器模式与装饰者模式有什么不同?