适配器模式

适配器模式，即把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法一起工作的两个类能够在一起工作。例如：笔记本的电源适配器、二脚转三脚的电源插座等等。

       适配器分成两种形式，分别是类的适配器模式和对象的适配器模式，它们的结构图如下图所示：

 

  

实现源码：（由于个人Rational Rose用的不熟，可能代码与上图有点差异）

 

类的适配器模式：

Java代码  

1. package adapter;   
2.   
3. public class Adaptee {   
4.     public String method1()   
5.     {   
6.         return "METHOD1";   
7.     }   
8. }   
9.   
10. package adapter;   
11.   
12. public interface Target {   
13.     /**  
14.      * Adaptee类有的方法  
15.      */  
16.     public String method1();   
17.     /**  
18.      * Adaptee类没有的方法  
19.      */  
20.     public String method2();   
21. }   
22.   
23.   
24. package adapter;   
25.   
26. public class Adapter extends Adaptee implements Target {   
27.   
28.     @Override  
29.     public String method2() {   
30.         // 调用Adaptee的method1()方法   
31.         return super.method1();   
32.     }   
33.   
34. }  

package adapter;public class Adaptee {	public String method1()	{		return "METHOD1";	}}package adapter;public interface Target {	/**	 * Adaptee类有的方法	 */	public String method1();	/**	 * Adaptee类没有的方法	 */	public String method2();}package adapter;public class Adapter extends Adaptee implements Target {	@Override	public String method2() {		// 调用Adaptee的method1()方法		return super.method1();	}}

 

 

对象适配器模式：

 

Java代码  

1. package adapter;   
2.   
3. public interface Target2 {   
4.     /**  
5.      * Adaptee2类有的方法  
6.      */  
7.     public String method1();   
8.     /**  
9.      * Adaptee2类没有的方法  
10.      */  
11.     public String method2();   
12. }   
13.   
14. package adapter;   
15.   
16. public class Adaptee2 {   
17.     public String method1()   
18.     {   
19.         return "METHOD1";   
20.     }   
21. }   
22.   
23. package adapter;   
24.   
25. public class Adapter2 implements Target {   
26.     private Adaptee2 adaptee2;   
27.        
28.     public Adapter2(Adaptee2 adaptee2)   
29.     {   
30.         super();   
31.         this.adaptee2 = adaptee2;   
32.     }   
33.        
34.     @Override  
35.     public String method1() {   
36.         // 调用Adaptee的method1()方法   
37.         return adaptee2.method1();   
38.     }   
39.        
40.     @Override  
41.     public String method2() {   
42.         // 个人的处理代码   
43.         return "";   
44.     }   
45.   
46. }  

package adapter;public interface Target2 {	/**	 * Adaptee2类有的方法	 */	public String method1();	/**	 * Adaptee2类没有的方法	 */	public String method2();}package adapter;public class Adaptee2 {	public String method1()	{		return "METHOD1";	}}package adapter;public class Adapter2 implements Target {	private Adaptee2 adaptee2;		public Adapter2(Adaptee2 adaptee2)	{		super();		this.adaptee2 = adaptee2;	}		@Override	public String method1() {		// 调用Adaptee的method1()方法		return adaptee2.method1();	}		@Override	public String method2() {		// 个人的处理代码		return "";	}}

 

 

什么情况下使用适配器模式：

1  系统需要使用现有的类，而此类的接口不符合系统的需要

2  想要简历一个可以重复使用的类，用于与一些配词之间没有太大关联的一些类，包括一些可能在将来引进的类 一起工作。

3  在设计里，需要改变多个已有的子类的接口，如果使用类的适配器，就要针对每一个子类做一个适配器类，而这不太实际。