设计模式学习笔记——适配器模式

正好看到Android中使用ListAdapter往ListView中添加信息，想起来Adapter适配器设计模式，拿出来学习了下

 

适配器模式的定义

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。(GoF)

 

综合一些资料来看，适配器达到的目的基本就是我有一个接口，而如今我需要扩展这个接口来实现一些新的特定功能，而这些功能又已经包含在了其他类中。我们自然是希望可以直接去使用这些已经写好的方法，而不用自己再动手，这时就用到了适配器模式，即创建一个新的类作为2者之间的桥梁

 

适配器模式有2种形式：类适配器，对象适配器

 

首先是类适配器

 

盗用一下UML图，这次没有自己画

情景：我们需要实现Target，而我们需要的功能Request()又已经在一个已经存在的类Adatpee中实现了，也就是SpecificRequest()，这时我们创建一个Adapter类把2者连接起来

Target接口：

public interface Target {
	public void Request();
}

 已经实现了我们需要方法的Adaptee类

public class Adaptee {
	public void SpecificRequest(){
		System.out.print("I'm SpecialRequest");
	}
}

 创建一个Adapter将两者连接起来

public class Adapter extends Adaptee implements Target{
	public void Request() {
		super.SpecificRequest();
	}
}

 最终我们在Client中就可以直接使用该方法而不需要重复编码了

public class Client {
	public static void main(String args[]){
		Target target=new Adapter();
		target.Request();
	}
}

 

在这基础上，我们碰到了一个问题，如果我们的Target方法要实现多个Request，而这些Request又分别在不同的类中有实现，那怎么办，按照上面的办法，我们必须extends 1 2 3，但是Java是不允许多重继承的

这时，就出现了适配器类的第二种形式：对象适配器

同样盗用一张UML图

 情景：仍然是我们有一个Target接口，其中包含了Request1(),Request2()，Request3()这3个我们需要的功能，而在不同的类Adaptee1，Adaptee2，Adaptee3中分别已经实现了我们需要的功能，现在需要创建一个适配器，将这些类与我们需要的Target连接起来

Target接口，包含3个需要实现的Request()方法

public interface Target {
	public void Request1();
	public void Request2();
	public void Request3();
}

 现有的Adaptee类1、2、3

public class Adaptee1 {
	public void SpecificRequest1(){
		System.out.println("I'm SpecialRequest1");
	}
}
public class Adaptee2 {
	public void SpecificRequest2(){
		System.out.println("I'm SpecialRequest2");
	}
}
public class Adaptee3 {
	public void SpecificRequest3(){
		System.out.println("I'm SpecialRequest3");
	}
}

 实现我们自己的适配器来连接2者

public class Adapter implements Target{
	private Adaptee1 adaptee1;
	private Adaptee2 adaptee2;
	private Adaptee3 adaptee3;
	
	public Adapter(Adaptee1 ad1,Adaptee2 ad2,Adaptee3 ad3){
		this.adaptee1=ad1;
		this.adaptee2=ad2;
		this.adaptee3=ad3;
	}
	
	public void Request1(){
		adaptee1.SpecificRequest1();
	}
	public void Request2(){
		adaptee2.SpecificRequest2();
	}
	public void Request3(){
		adaptee3.SpecificRequest3();
	}
}

 最终在Client中使用

public class Client {
	public static void main(String args[]){
		Adaptee1 ad1=new Adaptee1();
		Adaptee2 ad2=new Adaptee2();
		Adaptee3 ad3=new Adaptee3();
		Target target=new Adapter(ad1,ad2,ad3);
		target.Request1();
		target.Request2();
		target.Request3();
	}
}

 

适配器并不是通过继承来获取适配类（原）的功能的，而是通过适配类的对象来获取的，这就解决了java不能多继承所带来的不便了。这也是java提倡的编程思想之一，即尽量使用聚合不要使用继承。 

另外一种对象适配器使用的情况

当Target成为一个类的时候

Target类

public class Target {
	public void Request(){
		System.out.println("I'm Request");
	}
}

 Adaptee类

public class Adaptee {
	public void SpecificRequest(){
		System.out.print("I'm SpecialRequest");
	}
}

 实现的Adapter

public class Adapter extends Target{
	private Adaptee ad;
	
	public Adapter(Adaptee ad){
		super();
		this.ad=ad;
	}
	
	public void Request(){
		ad.SpecificRequest();
	}
}

 Client中的使用

public class Client {
	public static void main(String args[]){
		Adaptee ad=new Adaptee();
		Target target=new Adapter(ad);
		target.Request();
	}
}

 即 将Adaptee聚合到Adapter中

最后是所谓的隐藏接口的抽象适配器，例子就是WindowAdapter，它实现了接口WindowsListener中的所有方法，但都是空实现，这样在使用的时候，就不必继承所有方法，而只需要实现我们需要的方法即可。

 

评论

2 楼 cookiejj2010 2011-08-10  

吖吖邦 写道

楼主顶一个

谢谢 

1 楼 吖吖邦 2011-08-10  

楼主顶一个