适配器模式（Adapter Pattern）将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配不能一起工作的两个类协同工作。别名为：包装器（Wrapper）

1.2 工作原理

1）适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容
2）从用户的角度看不到被适配器，是解耦的
3）用户调用适配器转化出来的目标接口方法，适配器再调用被适配器的相关接口方法
4）用户收到反馈结果，感觉只是和目标接口交互
适配器模式Adapter Pattern - 图1

2.分类

2.1 类适配器模式(使用继承的适配器)

基本介绍

  • Adapter 类，通过继承src类，实现dst类接口，完成src->dst的适配

    实例

  • 实例说明 手机充电器的适配器，将220V交流电（src）转成5V直流电（dst）

  • 代码实现Voltage220V-src（被适配者）

image.png

事项和细节

  • Java是单继承机制，所以类适配器需要继承src类这点算是一个缺点，因为这要求dst必须是接口，有一定局限性
  • src类的方法再Adapter中都会暴露出来，也增加了使用的成本
  • 由于其继承了src类，所以它可以根据需求重写src类的方法，是的Adapter的灵活性增强 ```java //客户期望的接口——220V的电压充电 interface Target { void chargeBy220V(); }

//现有接口——只能通过110V电压充电 interface Adaptee { void chargeBy110V(); }

//现有接口的具体实现类，美国供电器——通过110V电压供电 class americanCharger implements Adaptee { @Override public void chargeBy110V() { System.out.println(“美国供电器，只为你服务，正在通过110V电压为您充电”); } }

//类适配器，通过继承现有接口来完成对现有接口的扩展 class Adapter extends americanCharger implements Target { @Override public void chargeBy220V() { super.chargeBy110V();//现有功能 System.out.println(“再加110V，达到220V，冲鸭！”);//对现有功能扩展 } }

//测试类 public class Test { public static void main(String[] args) throws FileNotFoundException { //类适配器使得代码逻辑混乱 //这种情况下仿佛Adapter是一种110V的美国供电器可以直接使用不需要其他信息 //具体可以和对象适配器对比以下 new Adapter().chargeBy220V(); } }

//输出 / 美国供电器，只为你服务，正在通过110V电压为您充电 再加110V，达到220V，冲鸭！ /

  3. <a name="eH2R5"></a>
  4. ## 2.2 对象适配器模式(使用委托的适配器)
  5. 1）基本思路和类的适配器模式相同，只是将Apapter类作修改，不是继承src类，而是持有src类的实例，已解决兼容性的问题。即持有src类，实现dst类接口。完成src-dst的适配 <br />2）根据“合成复用原则”，再系统中尽量使用关联关系来替代继承关系 <br />3）对象适配器模式是适配器模式常用的一种<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/297975/1654776147913-5fc4d3d6-b5a7-44ae-b33c-dd0255072dfd.png#clientId=ucadd29c5-3b0e-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u768c7b4a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=206&originWidth=551&originalType=binary&ratio=1&rotation=0&showTitle=false&size=78923&status=done&style=none&taskId=ucda9bd3b-51bf-4130-abe6-38c78686864&title=)
  6. ```java
  7. //客户期望的接口——220V的电压充电
  8. interface Target {
  9.     void chargeBy220V();
  10. }
  12. //现有接口——只能通过110V电压充电
  13. interface Adaptee {
  14.     void chargeBy110V();
  15. }
  17. //现有接口的具体实现类，美国供电器——通过110V电压供电
  18. class americanCharger implements Adaptee {
  19.     @Override
  20.     public void chargeBy110V() {
  21.         System.out.println("美国供电器，只为你服务，正在通过110V电压为您充电");
  22.     }
  23. }
  25. //类适配器，通过继承现有接口来完成对现有接口的扩展，使得能够110V供电
  26. class Adapter implements Target {
  27.     Adaptee adaptee;//持有现有接口具体实现对象的引用
  29.     public Adapter(Adaptee adaptee) {
  30.         this.adaptee = adaptee;
  31.     }
  33.     @Override
  34.     public void chargeBy220V() {
  35.         adaptee.chargeBy110V();//该对象的现有功能
  36.         System.out.println("再加110V，达到220V，冲鸭！");//对现有功能扩展
  37.     }
  38. }
  40. //测试类
  41. public class Test {
  42.     public static void main(String[] args) throws FileNotFoundException {
  43.         //现在我们有一个美国110V供电站，但我们无法使用
  44.         Adaptee adaptee = new americanCharger();
  46.         //我们将这个供电器交给适配器，适配器转换为220V供电器
  47.         Adapter adapter = new Adapter(adaptee);
  49.         //接下来我们通过适配器充电就好了
  50.         adapter.chargeBy220V();        
  51.     }
  52. }
  53. //输出同上

如果实现适配有多种方式的话，我们可以将适配器类Adapter声明为抽象类，并由子类扩展它:

  1. //客户期望的接口——220V的电压充电
  2. interface Target {
  3.     void chargeBy220V();
  4. }
  6. //现有接口——只能通过110V电压充电
  7. interface Adaptee {
  8.     void chargeBy110V();
  9. }
  11. //现有接口的具体实现类，美国供电器——通过110V电压供电
  12. class americanCharger implements Adaptee {
  13.     @Override
  14.     public void chargeBy110V() {
  15.         System.out.println("美国供电器，只为你服务，正在通过110V电压为您充电");
  16.     }
  17. }
  19. //抽象类适配器，通过继承现有接口来完成对现有接口的扩展
  20. abstract class Adapter implements Target {
  21.     Adaptee adaptee;//持有现有接口具体实现对象的引用
  23.     public Adapter(Adaptee adaptee) {
  24.         this.adaptee = adaptee;
  25.     }
  26. }
  28. //中国自制
  29. class ChinaMakeAdapter extends Adapter {
  31.     public ChinaMakeAdapter(Adaptee adaptee) {
  32.         super(adaptee);
  33.     }
  35.     @Override
  36.     public void chargeBy220V() {
  37.         adaptee.chargeBy110V();//该对象的现有功能
  38.         System.out.println("再加110V，达到220V，认准中国制造，冲鸭！");//对现有功能扩展
  39.     }
  40. }
  42. //测试类
  43. public class Test {
  44.     public static void main(String[] args) throws FileNotFoundException {
  45.         //现在我们有一个美国110V供电站，但我们无法使用
  46.         Adaptee adaptee = new americanCharger();
  48.         //我们将这个供电站交给中国制造的适配器
  49.         Adapter adapter = new ChinaMakeAdapter(adaptee);
  51.         //接下来我们通过适配器充电就好了
  52.         adapter.chargeBy220V();
  53.     }
  54. }
  55. //输出同上

事项和细节

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

2.3 接口适配器模式

基本介绍

1）适配器模式（Default Adapter Patterb）或缺省适配器模式
2）当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口每个方法实现一个 默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类地某些方法来实现需求
3）适用于一个接口不想使用其所有的方法的情况