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

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

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

Java代码

1. //鸭子具有呱呱叫和飞的能力   
2. public interface Duck {   
3.     public void quack();   
4.     public void fly();   
5. }   
6. //绿头鸭是鸭子的子类   
7. public class MallardDuck implements Duck {   
8.     public void quack() {   
9.         System.out.println("Quack");   
10.     }   
11.     public void fly() {   
12.         System.out.println("I'm flying");   
13.     }   
14. }   
15. //介绍一个新的飞禽:火鸡   
16. public interface Turkey {   
17.     public void gobble();   //火鸡不会呱呱叫,只会咯咯叫   
18.     public void fly();  //火鸡会飞,但是飞不远   
19. }   
20. //这是火鸡的具体实现   
21. public class WildTurkey implements Turkey {   
22.     public void gobble() {   
23.         System.out.println("Gobble gobble");   
24.     }   
25.     public void fly() {   
26.         System.out.println("I'm flying a short distance");   
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. public class TurkeyAdapter implements Duck {   
5.     Turkey turkey;   
6.     //这里我们利用构造器去得要适配的对象引用   
7.     public TurkeyAdapter(Turkey turkey) {   
8.         this.turkey = turkey;   
9.     }   
10.     //现在我们需要实现接口中的所有方法,这个转换很简单,只要调用gobble()就行了   
11.     public void quack() {   
12.         turkey.gobble();   
13.     }   
14.     //虽然2个接口都具备fly()方法,火鸡的飞行距离很短,不像鸭子可以长途飞行,   
15.     //要让火鸡与鸭子的飞行能够对应,我们连续调用5次火鸡的fly()方法   
16.     public void fly() {   
17.         for(int i=0; i < 5; i++) {   
18.             turkey.fly();   
19.         }   
20.     }   
21. }   
22. //我们再来测试一下这个适配器   
23. public class DuckTestDrive {   
24.     public static void main(String[] args) {   
25.         MallardDuck duck = new MallardDuck();   //先创建一只鸭子   
26.         WildTurkey turkey = new WildTurkey();   //再创建一只火鸡   
27.         //然后将火鸡包装进一个火鸡适配器中,使它看起来像一只鸭子   
28.         Duck turkeyAdapter = new TurkeyAdapter(turkey);   
29.         //先测试这只火鸡,让它咯咯叫,再让它飞行   
30.         System.out.println("The Turkey says...");   
31.         turkey.gobble();   
32.         turkey.fly();   
33.         //测试鸭子   
34.         System.out.println("/nThe Duck says...");   
35.         testDuck(duck);   
36.         //重要的地方:试着传入一个加装是鸭子的火鸡   
37.         System.out.println("/nThe TurkeyAdapter says...");   
38.         testDuck(turkeyAdapter);   
39.     }   
40.     static void testDuck(Duck duck) {   
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. public class EnumerationIterator implements Iterator {  //适配器看起来就是一个Iterator   
2.     //我们使用组合的方式,将枚举结合进适配器中,用实例变量记录   
3.     Enumeration enumeration;   
4.     public EnumerationIterator(Enumeration enumeration) {   
5.         this.enumeration = enumeration;   
6.     }   
7.     //迭代器的hasNext其实是委托给enumeration的hasMoreElements方法   
8.     public boolean hasNext() {   
9.         return enumeration.hasMoreElements();   
10.     }   
11.     //迭代器的next其实是委托给enumeration的nextElement方法   
12.     public Object next() {   
13.         return enumeration.nextElement();   
14.     }   
15.     //很不幸,我们不能支持迭代器的remove方法,所以必须放弃,这里是抛出一个异常   
16.     public void remove() {   
17.         throw new UnsupportedOperationException();   
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();}}

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