基本介绍：

1、适配器模式将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。也被称为包装器。

2、主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

工作原理：

1、将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容

2、从用户的角度看不到被适配者，是解耦的

3、用户调用适配器转化出来的目标方法，适配器再调用被适配者的相关接口方法

4、用户收到反馈结果，感觉只是和目标接口交互

类适配器模式

基本介绍：Adapter类，通过继承src类，实现dst类接口，完成src->dst的适配

例如有一个给手机充电的案例，手机需要5V电压，交流电是220V，这就需要一个适配器将220V的电压降为5V

代码示例：

  1. /**
  2.  * 被适配的类
  3.  */
  4. public class HighVoltage {
  6.     /**
  7.      * 输出220V电压
  8.      * @return
  9.      */
  10.     public Integer outputHigh(){
  11.         int src = 220;
  12.         System.out.println("输出电压："+src);
  13.         return src;
  14.     }
  15. }
  17. /**
  18.  * 适配接口
  19.  */
  20. public interface LowVoltage {
  22.     /**
  23.      * 输出低电压
  24.      * @return
  25.      */
  26.     Integer outputLow();
  27. }
  29. /**
  30.  * 类适配器
  31.  */
  32. public class AdapterVoltage extends HighVoltage implements LowVoltage{
  33.     @Override
  34.     public Integer outputLow() {
  35.         Integer src = outputHigh();
  36.         int dst = src - 215;
  37.         System.out.println("电压转换："+dst);
  38.         return dst;
  39.     }
  40. }
  43. public class Phone {
  44.     /**
  45.      * 充电
  46.      * @param lowVoltage
  47.      */
  48.     public void charging(LowVoltage lowVoltage){
  49.         if (lowVoltage.outputLow()==5){
  50.             System.out.println("开始充电");
  51.         }else {
  52.             System.out.println("无法充电");
  53.         }
  54.     }
  55. }
  58. public class Client {
  59.     public static void main(String[] args) {
  60.         Phone phone = new Phone();
  61.         phone.charging(new AdapterVoltage());
  62.     }
  63. }

调用结果

  1. 输出电压：220
  2. 电压转换：5
  3. 开始充电

注意事项：

1、Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性

2、src类的方法在Adapter中都会暴露出来，也增加了使用成本

3、由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了

对象适配器模式

基本介绍：

1、基本思路和类适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。即：持有src类，实现dst类接口，完成src->dst的适配

2、根据“合成复用原则”，在系统中尽量使用关联关系来代替继承关系

3、对象适配器模式是适配器模式常用的一种

代码示例：

  1. /**
  2.  * 被适配的类
  3.  */
  4. public class HighVoltage {
  6.     /**
  7.      * 输出220V电压
  8.      * @return
  9.      */
  10.     public Integer outputHigh(){
  11.         int src = 220;
  12.         System.out.println("输出电压："+src);
  13.         return src;
  14.     }
  15. }
  17. /**
  18.  * 适配接口
  19.  */
  20. public interface LowVoltage {
  22.     /**
  23.      * 输出低电压
  24.      * @return
  25.      */
  26.     Integer outputLow();
  27. }
  29. /**
  30.  * 对象适配器
  31.  */
  32. public class ObjAdapterVoltage implements LowVoltage {
  34.     private HighVoltage highVoltage;
  36.     /**
  37.      * 通过构造器传入高电压实例
  38.      * @param highVoltage 高电压
  39.      */
  40.     public ObjAdapterVoltage(HighVoltage highVoltage){
  41.         this.highVoltage = highVoltage;
  42.     }
  44.     @Override
  45.     public Integer outputLow() {
  46.         Integer dst = 0;
  47.         if (null!=highVoltage){
  48.             Integer src = highVoltage.outputHigh();
  49.             dst = src - 215;
  50.             System.out.println("电压转换："+dst);
  51.         }
  52.         return dst;
  53.     }
  54. }
  56. public class Phone {
  57.     /**
  58.      * 充电
  59.      * @param lowVoltage
  60.      */
  61.     public void charging(LowVoltage lowVoltage){
  62.         if (lowVoltage.outputLow()==5){
  63.             System.out.println("开始充电");
  64.         }else {
  65.             System.out.println("无法充电");
  66.         }
  67.     }
  68. }
  71. public class Client {
  72.     public static void main(String[] args) {
  73.         Phone phone = new Phone();
  74.         phone.charging(new ObjAdapterVoltage(new HighVoltage()));
  75.     }
  76. }

与类适配器相比，只是改变了适配器类和调用类，其他的没有改变

注意事项：

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

2、使用成本更低、更灵活

接口适配器模式

基本介绍：

1、当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求

2、适用于一个接口不想使用其所有的方法的情况

3、也称为缺省适配器模式

代码示例：

  1. public interface InterfaceForAda {
  2.     public void method1();
  3.     public void method2();
  4.     public void method3();
  5.     public void method4();
  6. }
  8. /**
  9.  * 抽象类来实现接口，里面是空方法
  10.  */
  11. public abstract class AbsAdapter implements InterfaceForAda {
  12.     @Override
  13.     public void method1() {
  14.     }
  15.     @Override
  16.     public void method2() {
  17.     }
  18.     @Override
  19.     public void method3() {
  20.     }
  21.     @Override
  22.     public void method4() {
  23.     }
  24. }
  26. public class Client {
  27.     public static void main(String[] args) {
  28.         //使用的时候想用哪个方法就重写哪个方法
  29.         AbsAdapter absAdapter = new AbsAdapter() {
  30.             @Override
  31.             public void method2() {
  32.                 System.out.println("使用method2方法");
  33.             }
  34.         };
  35.         absAdapter.method2();
  36.     }
  37. }

适配器模式在SpringMVC框架应用的源码分析： SpringMVC中的HandlerAdapter，就使用了适配器模式

适配器模式注意事项：

1、三种命名方式，是根据src是以怎样的形式给到Adapter（在Adapter里的形式）来命名的

2、类适配器：以类给到，在Adapter里，就是将src当做类，继承

  1. 对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有
  3. 接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

3、Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作

4、实际开发中，实现起来不拘泥于上述三种经典模式