设计模式—（适配器模式）（桥接模式）

适配器模式

类适配器

介绍：主要目的是兼容性，让原本不匹配的接口变得匹配

适配器分为：类适配器模式，对象适配器模式，接口适配器模式

实例：

通过适配器把电压220V转化为5V

类图：

代码：

写一个电压为220V的类

public class V220 {
	public int output220() {
		int src=220;
		System.out.println("dian"+src+"V");
		return src;
	}
}

写一个接口

public interface IV5 {
	public int output5();
}

写一个适配器，因为java是单继承所以它需要继承V220类，并实现IV5的接口。

public class VAdapter extends V220 implements IV5{
	@Override
	public int output5() {
		// TODO Auto-generated method stub
		int src=output220();
		int dstV=src / 44;
		return dstV;
	}
}

编写手机类，在类中写入充电方法。

public class Phone {
	public void charging(IV5 iv5) {
		if(iv5.output5()==5) {
			System.out.println("chong dian ya wei 5");
		}else if (iv5.output5()>5) {
			System.out.println("bu neng"+iv5.output5());
		}
	}
}

编写实现类

public static void main(String[] args) {
		Phone phone = new Phone();
		phone.charging(new VAdapter());
	}

过程：创建一个手机类，然后调用手机类的充电方法，在iv5.output5()方法实现电压转换，通过if判断电压是否5V。最后充电。

对象适配器

由之前的继承变成了聚合，私有化，构造器创建，重写ouput5方法

public class VAdapter implements IV5{
	private V220 v220;

	public VAdapter(V220 v220) {
		super();
		this.v220 = v220;
	}
	@Override
	public int output5() {
		int dst=0;
		if (null!=v220) {
			int src=v220.output220();
			dst=src/44;
			System.out.println("wan cheng 5");
		}
		return dst;
	}

}

主类Cilent

public class Client {
	public static void main(String[] args) {
		Phone phone = new Phone();
		phone.charging(new VAdapter(new V220()));
	}
}

接口适配器模式

一个接口有什么方法，当不想全部使用的情况下用接口适配器模式

编写四个接口

public interface Interface1 {
	public void m1();
	public void m2();
	public void m3();
	public void m4();
}

编写一个抽象类实现接口的空方法

public abstract class Abs implements Interface1{
	public void m1() {}
	public void m2() {}
	public void m3() {}
	public void m4() {}
}

最后要哪个重写哪个

public class Client {
	public static void main(String[] args) {
		Abs abs=new Abs() {
			@Override
			public void m1() {
				// TODO Auto-generated method stub
				super.m1();
			}
		};
		abs.m1();
	}
}

适配器源码分析

在springmvc框架中，SpringMVC中的HandlerAdapter

桥接模式

介绍：

1. 将实现与抽象放在两个不同的类层次中，使得他们可以独立改变
2. 结构性设计模式
3. 桥接（Bridge）模式基于类的最小设计原则

例子：手机里面很多样式，有开机关机方法，为了方便，创建一个Brand接口写入手机的方法，创建手机品牌类继承Brand接口实现开机关机等方法，后创建一个Phone手机抽象类在里面创建一个Brand品牌对象创建构造器传入，调用Brand开机关机等方法，创建Phone类的子类（折叠屏，翻转屏）继承Phone实现父类的有参构造调用方法实际上是调用父类Phone的方法，Phone里面的方法是调用的Brand的方法。Phone就是那个桥。

类图：

创建一个Brand接口写入手机的方法

public interface Brand { void open(); void close(); void call(); }

创建手机品牌类继承Brand接口实现开机关机等方法

public class XiaoM implements Brand{

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("M:KAI JI");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("M:GUAN JI");
	}

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("M:DA DIAN HUA");
	}

}
------------------------------------------------
public class Vivo implements Brand{

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("Vivo:KAI JI");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("Vivo:KAI JI");
	}

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("Vivo:KAI JI");
	}

}

创建一个Phone手机抽象类在里面创建一个Brand品牌对象创建构造器传入，调用Brand开机关机等方法

public abstract class Phone {
	private Brand brand;

	public Phone(Brand brand) {
		super();
		this.brand = brand;
	}
	protected void open() {
		this.brand.open();
	}
	protected void close() {
		this.brand.close();
	}
	protected void call() {
		this.brand.call();
	}
}

创建Phone类的子类（折叠屏，翻转屏）继承Phone实现父类的有参构造调用方法实际上是调用父类Phone的方法

public class FoldedPhone extends Phone{

	public FoldedPhone(Brand brand) {
		super(brand);
		// TODO Auto-generated constructor stub
	}
	public void open() {
		super.open();
		System.out.println("zhe die kai ji");
	}
	public void close() {
		super.close();
		System.out.println("zhe die guan ji");
	}
	public void call() {
		super.call();
		System.out.println("zhe die da dian hua");
	}
}

主类测试

public class Client {
	public static void main(String[] args) {
		//样式+品牌
		Phone phone = new FoldedPhone(new XiaoM());
		phone.open();
		phone.call();
		phone.close();
	}
}

注意细节：

1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象分布和现实部分独立开
2. 对于系统高层部分只需要知道抽象部分和实现部分的接口就行了
3. 桥接模式替代多继承减少子类的个数，降低系统管理和维护成本
4. 桥接模式要求正确识别系统中两个独立的变化维度

应用场景：

不希望使用继承或因为多层继承导致系统的类的个数急剧增加

常见的场景：jdbc驱动程序，银行转账，消息管理