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

什么是适配器模式？

适配器模式（有时候也称包装样式或者包装）就是将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

看一个我们日常生活中的图：

如果出国旅行，肯定会买一些国外的优质的电器回来，但是国外的电器插头可能是这样的。。

而国内的插座确实这样的。。

肯定是插不进去的。。怎么办呢？神通广大的适配器就该出场了！

这下应该可以理解适配器是用来干嘛的了吧，其实设计模式中的适配器模式和这个道理是一样的。

我们来看一下适配器模式的类图

PS：我画的可能有点丑。。

适配器主要的作用就是将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

下面我们来举一个具体的例子说明一下吧：

《暮光之城》里的吸血鬼家族，今天晚上要举办一场吸血鬼舞会，一名人类战士吸血鬼研究学者得到消息也想混进去趁机研究一下吸血鬼，但是如果他直接去，那肯定就被吸血鬼们发现了，所以他要伪装一下，下面我们用代码来实现一下

人类接口

//人类接口
public interface Human {
	//进食
	public void eat();
	//运动
	public void run();
}

人类战士类

public class Soldier implements Human {

	@Override
	public void eat(){
		// TODO Auto-generated method stub
		System.out.println("吃饭");
	}

	@Override
	public void run(){
		// TODO Auto-generated method stub
		System.out.println("跑得很慢");
	}
}

PS：这里跑得慢，肯定是跟吸血鬼们比较的，这哥们在人类中肯定是精英。

吸血鬼接口

//吸血鬼接口
public interface Vampire {
	//进食
	public void suckBlood();
	//运动
	public void run();
}

吸血鬼战士类

public class VampireWarriors implements Vampire {

	@Override
	public void suckBlood() {
		// TODO Auto-generated method stub
		System.out.println("吸血");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("跑得很快");
	}
}

好了下面我们就要对这位人类战士进行一下化妆了

其实在适配器模式中，适配有两种方法

对象适配器模式
-- 在这种适配器模式中，适配器容纳一个它包裹的类的实例。在这种情况下，适配器调用被包裹对象的物理实体。
类适配器模式
-- 这种适配器模式下，适配器继承自已实现的类（一般多重继承 ps：java中可以通过接口多继承）。

我们先来实现一下：

对象适配器模式：

//对象适配模式
public class SoldierAdapter implements Vampire {
	
	//被适配的士兵类
	private Soldier soldier;
	
    //在构造函数中传入士兵类
	public SoldierAdapter(Soldier soldier)
	{
		this.soldier=soldier;
	}
	
	//伪装吸血鬼进食
	@Override
	public void suckBlood() {
		// TODO Auto-generated method stub
		soldier.eat();
		System.out.println("饭的内容就是血");
	}
	
	//伪装吸血鬼运动，因为跑得慢所以要多跑几次
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<5;i++)
		{
			soldier.run();
		}
	}
}

测试一下：

测试类

public class MainTest {
	public static void main(String[] args) {
		
		//人类战士
		Soldier soldier=new Soldier();
		
		//吸血鬼战士
		VampireWarriors vampireWarriors=new VampireWarriors();
		
		//伪装的吸血鬼战士
		Vampire vampire2humanAdapter=new SoldierAdapter(soldier);
		
		//人类战士行为
		System.out.println("人类战士：");
		soldier.eat();
		soldier.run();
		
		System.out.println();
		
		//吸血鬼战士行为
		System.out.println("吸血鬼战士：");
		vampireWarriors.suckBlood();
		vampireWarriors.run();
		
		System.out.println();
		
		//伪装者的行为
		System.out.println("人类战士冒充吸血鬼战士：");
		vampire2humanAdapter.suckBlood();
		vampire2humanAdapter.run();	
	}
}

还不错，但愿吸血鬼发现不了这个兄弟。。

下面我们来实现一下类适配器模式

//类适配器模式
public class SoldierAdapter2 extends Soldier implements Vampire {
	
	//伪装吸血鬼的行为
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<5;i++)
		{
			super.run();
		}
	}

	@Override
	public void suckBlood() {
		// TODO Auto-generated method stub
		super.eat();
		System.out.println("饭的内容就是血");
	}
}

测试一下

public class MainTest {
	public static void main(String[] args) {
		
		//人类战士
		Soldier soldier=new Soldier();
		
		//吸血鬼战士
		VampireWarriors vampireWarriors=new VampireWarriors();
		
		//伪装的吸血鬼战士
		Vampire vampire2humanAdapter=new SoldierAdapter2();//这里就不用传入对象了
		
		//人类战士行为
		System.out.println("人类战士：");
		soldier.eat();
		soldier.run();
		
		System.out.println();
		
		//吸血鬼战士行为
		System.out.println("吸血鬼战士：");
		vampireWarriors.suckBlood();
		vampireWarriors.run();
		
		System.out.println();
		
		//伪装者的行为
		System.out.println("人类战士冒充吸血鬼战士：");
		vampire2humanAdapter.suckBlood();
		vampire2humanAdapter.run();	
	}
}

结果是一样的啦

我们比较一下对象适配器是类适配器：

类适配器：
由于适配器类是适配者类的子类，因此可以再适配器类中置换一些适配者的方法，使得适配器的灵活性更强。但是对于Java、C#等不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为接口，不能为类，其使用有一定的局限性，不能将一个适配者类和他的子类同时适配到目标接口。

对象适配器：
把多个不同的适配者适配到同一个目标，也就是说，同一个适配器可以把适配者类和他的子类都适配到目标接口。但是，与类适配器模式相比，要想置换适配者类的方法就不容易。

再来看看适配器模式的优点是 场景

1、将目标类和适配者类解耦
2、增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性
3、灵活性和扩展性都非常好，符合开闭原则

适配器模式的适用场景： 
1、我们在使用第三方的类库，或者说第三方的API的时候，我们通过适配器转换来满足现有系统的使用需求。
2、我们的旧系统与新系统进行集成的时候，我们发现旧系统的数据无法满足新系统的需求，那么这个时候，我们可能需要适配器，完成调用需求。