千峰Java教程：066. 适配器设计模式

17、适配器模式

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

可以看上面的图片，比如第一个类跟第三个类，一个是方的一个是圆的，没法怼进去，这时候就需要中间那个类，用来连接方形和圆形。在生活中也有这样的例子，如插线盘，还有电脑的电源适配器，把电源三角口转换成计算机的圆口插到电脑上。

我们先来一串代码：

public class Demo1
{
	public static void main(String[] args)
	{
		IPowerA powerA = new PowerAImpl();//建立一个子类
		work(powerA);
	}
	//用IPowerA接口的时候下面设计一个静态方法
	public static void work(IPowerA a)
	{
		System.out.println("正在连接...");
		a.insert();
		System.out.println("工作结束。");
	}//写完这个方法，就要在主函数中用这个方法了
}

interface IPowerA//设定一个电源A的接口
{
	public void insert();//插入电源A
}
class PowerAImpl implements IPowerA
{
	public void insert()
	{
		System.out.println("电源A开始工作");
	}
}
/*
结果：
正在连接...
电源A开始工作
工作结束。
*/

我们看上面的代码，他是这样子的：

现在需求发生了变化，适配器有点像补救的办法一样，要把这个图象换成第一个图象，中间加一个适配器

public class Demo1
{
	public static void main(String[] args)
	{
		IPowerA powerA = new PowerAImpl();//建立一个子类
		//work(powerA);
		
		/*IPowerB powerB = new PowerBImpl();
		work(powerB);注释的这两行是没有办法用的，因为work里面的参数必须是IPowerA，现在建立的是IPowerB类型的*/
		
		//这样来：
		IPowerB powerB = new PowerBImpl();//先建立一个IPowerB类
		Adapter adapter = new Adapter(powerB);//调用Adapter类，把电源B转化成电源A
		work(adapter);//最后调用
	}
	//用IPowerA接口的时候下面设计一个静态方法
	public static void work(IPowerA a)
	{
		System.out.println("正在连接...");
		a.insert();
		System.out.println("工作结束。");
	}//写完这个方法，就要在主函数中用这个方法了
}

interface IPowerA//设定一个电源A的接口
{
	public void insert();//插入电源A
}
class PowerAImpl implements IPowerA
{
	public void insert()
	{
		System.out.println("电源A开始工作");
	}
}

interface IPowerB//那我们这时候添加一个B电源
{
	public void connet();
}
class PowerBImpl implements IPowerB
{
	public void connet()
	{
		System.out.println("电源B开始工作");
	}
}

class Adapter implements IPowerA//这里定义一个适配器，这个类是IPowerA的子类
{
	private IPowerB powerB;
	public Adapter(IPowerB powerB)//建立一个构造器
	{
		this.powerB = powerB;
	}
	public void insert()//这里把B转换成了A
	{
		powerB.connet();
	}
}
/*
结果：
正在连接...
电源B开始工作
工作结束。
*/

这样，就把B变成了A。此时A接口没有改变，B接口也没有改变（对修改关闭，对扩展开放）

 

还有一种用法:

public class Demo1
{
	public static void main(String[] args)
	{
		IAnimal dog = new Dog();
		dog.run();
	}
}

interface IAnimal//这时候我们新建一个接口，有唱、哭、跑、游泳四个方法
{
	public void sing();
	public void cry();
	public void run();
	public void swim();
}
class Dog implements IAnimal//继承IAnimal的时候，要把接口里的方法都继承下来，但可以不实现。我们关注跑这个方法
{
	public void sing(){}
	public void cry(){}
	public void run()
	{
		System.out.println("我是疯狗，疯狂地跑");
	}
	public void swim(){}
}
/*
结果：
我是疯狗，疯狂地跑
*/

我们定义一个适配器，子类就不用implements IAnimal了

public class Demo1
{
	public static void main(String[] args)
	{
		IAnimalFunction dog = new Dog();//这里的IAnimal就要改成IAnimalFunction了
		dog.run();
	}
}

interface IAnimal//这时候我们新建一个接口，有唱、哭、跑、游泳四个方法
{
	public void sing();
	public void cry();
	public void run();
	public void swim();
}

abstract class IAnimalFunction//适配器
{
	public void sing(){}
	public void cry(){}
	public void run(){}
	public void swim(){}
}

class Dog extends IAnimalFunction//这个就变成了IAnimalFunction的子类，用来转接用，不用再加唱、哭、游泳的方法了
{
	public void run()
	{
		System.out.println("我是疯狗，疯狂地跑");
	}
}
/*
结果：
我是疯狗，疯狂地跑
*/

OO设计原则：

1、面向接口编程（面向抽象编程）

2、封装变化

3、多用组合，少用继承

4、对修改关闭，对扩展开放