适配器模式（由浅到深学习设计模式）

适配器模式

---

1. 概述

将原来不兼容的接口融合在一起工作。主要是为了兼容性，让原本不匹配不能一起工作的两个类可以协调一起工作。

2. 应用场景（何时使用）

转载：https://blog.csdn.net/ljb622/article/details/104856586

3. 三种适配器（类适配器、对象适配器、接口适配器）

1、类适配器

以生活中充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 src (即被适配者)，我们
的目 dst(即 目标)是 5V 直流电

步骤如下：
1)	220V电压类，输出220V电压（被适配的类，继承类型父类）
2)  5V电压类，输出5V电压（适配类，接口类型）
3)  适配器类，进行220V转化5V的适配
4)  手机类，进行5V充电
5)	代码实现  

Voltage220V类

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
//被适配的类
public class Voltage220V {
	//输出220V的电压
	public int output220V() {
		int src = 220;
		return src;
	}
}

IVoltage5V

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public interface IVoltage5V {
	public int output5V();
}

VoltageAdapter

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

	@Override
	public int output5V() {
		// TODO Auto-generated method stub
		//获取到220V电压
		int srcV = output220V();
		int dstV = srcV / 44 ; //转成 5v
		return dstV;
	}

}

Phone

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Phone {

	//充电
	public void charging(IVoltage5V iVoltage5V) {
		if(iVoltage5V.output5V() == 5) {
			System.out.println("电压为5V, 可以充电~~");
		} else if (iVoltage5V.output5V() > 5) {
			System.out.println("电压大于5V, 不能充电~~");
		}
	}
}

客户端调用

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(" === 类适配器模式 ====");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter());
	}

}

优缺点：
1)	Java 是单继承机制，所以类适配器需要继承 src 类这一点算是一个缺点, 因为这要求 dst 必须是接口，有
一定局限性
2)	src 类的方法在 Adapter 中都会暴露出来，也增加了使用的成本
3)	由于其继承了 src 类，所以它可以根据需求重写 src 类的方法，使得 Adapter 的灵活性增强了

2、对象适配器

还是上面的实例，只是适配器代码写法改变，把继承换成了组合对象

步骤如下：
1)	220V电压类，输出220V电压（被适配的类，继承类型父类）
2)  5V电压类，输出5V电压（适配类，接口类型）
3)  适配器类，进行220V转化5V的适配，这里不再是继承被适配器，而是利用对象组合使用
4)  手机类，进行5V充电
5)	代码实现  

Voltage220V类

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Voltage220V {
	//输出220V的电压，不变
	public int output220V() {
		int src = 220;
		System.out.println("电压=" + src + "伏");
		return src;
	}
}

IVoltage5V类

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public interface IVoltage5V {
	public int output5V();
}

VoltageAdapter类

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class VoltageAdapter  implements IVoltage5V {

	private Voltage220V voltage220V; // 关联关系-聚合


	//通过构造器，传入一个 Voltage220V 实例
	public VoltageAdapter(Voltage220V voltage220v) {

		this.voltage220V = voltage220v;
	}



	@Override
	public int output5V() {

		int dst = 0;
		if(null != voltage220V) {
			int src = voltage220V.output220V();//获取220V 电压
			System.out.println("使用对象适配器，进行适配~~");
			dst = src / 44;
			System.out.println("适配完成，输出的电压为=" + dst);
		}

		return dst;

	}

}

Phone类

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Phone {

	//充电
	public void charging(IVoltage5V iVoltage5V) {
		if(iVoltage5V.output5V() == 5) {
			System.out.println("电压为5V, 可以充电~~");
		} else if (iVoltage5V.output5V() > 5) {
			System.out.println("电压大于5V, 不能充电~~");
		}
	}
}

客户端调用

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(" === 对象适配器模式 ====");
		Phone phone = new Phone();
		phone.charging(new VoltageAdapter(new Voltage220V()));
	}

}

优缺点：
1)	对象适配器和类适配器其实算是同一种思想，只不过实现方式不同
2)  根据合成复用原则，使用组合替代继承， 所以它解决了类适配器必须继承 src 的局限性问题，也不再要求
dst必须是接口
3)	使用成本更低，更灵活

3、接口适配器

Android 中的属性动画 ValueAnimator 类可以通过 addListener(AnimatorListener listener)方法添加监听
器， 有时候我们不想实现 Animator.AnimatorListener 接口的全部方法，我们只想监听 onAnimationStart，
我们会如下写：

步骤如下：
1)	写一个接口类，里面包含所有方法
2)  适配器，它是一个抽象类，实现接口，这里是空实现
3)  调用时，只需重写某个接口，然后调用，即可完成接口适配
3)	代码实现  

Interface4类，里面包含四个接口

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public interface Interface4 {
	public void m1();
	public void m2();
	public void m3();
	public void m4();
}

AbsAdapter类，适配器抽象类，空实现Interface4

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public abstract class AbsAdapter implements Interface4 {

	//默认实现
	public void m1() {

	}

	public void m2() {

	}

	public void m3() {

	}

	public void m4() {

	}
}

客户端调用

/**
 * @author 漆剑
 * @date 2021-03-27
 * @description
 */
public class Client {
	public static void main(String[] args) {

		AbsAdapter absAdapter = new AbsAdapter() {
			//只需要去覆盖我们 需要使用 接口方法
			@Override
			public void m1() {
				// TODO Auto-generated method stub
				System.out.println("使用了m1的方法");
			}
		};

		absAdapter.m1();
	}
}

4. 总结

1. 三种命名方式，是根据 src 是以怎样的形式给到 Adapter（在 Adapter 里的形式）来命名的。
2. 类适配器：以类给到，在 Adapter 里，就是将 src 当做类，继承
   对象适配器：以对象给到，在 Adapter 里，将 src 作为一个对象，持有
   接口适配器：以接口给到，在 Adapter 里，将 src 作为一个接口，实现
3. Adapter 模式最大的作用还是将原本不兼容的接口融合在一起工作
4. 实际开发中，实现起来不拘泥于我们讲解的三种经典形式

由于水平有限，本博客难免有不足，恳请各位大佬不吝赐教！