适配器模式指的是将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容。

    【分类】

    • 类适配器模式：通过继承src类，实现dst类接口，完成src->dst的适配；
    • 对象适配器模式：通过持有src类，实现dst类接口，完成src->dst的适配（使用组合关系来替代继承，推荐使用）；
    • 默认适配器模式：也叫接口适配器/缺省适配器，当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现(空方法)，那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求，适用于一个接口不想使用其所有的方法的情况。

    【角色】

    • 目标角色（Target）：该角色定义把其他类转换为何种接口，也就是我们的期望接口。
    • 源角色（Adaptee）：需要转换成目标角色的源角色，它是已经存在的、运行良好的类或对象，经过适配器角色的包装，它会成为一个崭新的角色。
    • 适配器角色（Adapter）：适配器模式的核心角色，其他两个角色都是已经存在的角色，而适配器角色是需要新建立的，它的职责非常简单：把源角色通过继承或者类关联的方法转换为目标角色。
      1. /**
      2. * 苹果手机（目标角色）
      3. */
      4. public interface ApplePhone {
      5.   /**
      6.    * 苹果耳机
      7.    */
      8.   void appleHeadset();
      9.   /**
      10.    * 苹果充电器
      11.    */
      12.   void appleCharger();
      13. }
      1. /**
      2. * 安卓手机（源角色）
      3. */
      4. public interface AndroidPhone {
      5.   /**
      6.    * 安卓耳机
      7.    */
      8.   void androidHeadset();
      9.   /**
      10.    * 安卓充电器
      11.    */
      12.   void androidCharger();
      13. }
      1. /**
      2. * 安卓手机（源角色）
      3. */
      4. public class AndroidPhoneImpl implements AndroidPhone {
      5.   @Override
      6.   public void androidHeadset() {
      7.       System.out.println("安卓耳机");
      8.   }
      9.   @Override
      10.   public void androidCharger() {
      11.       System.out.println("安卓充电器");
      12.   }
      13. }
      【类适配器模式】
      1. /**
      2. * 类适配器
      3. */
      4. public class ClassAdapter extends AndroidPhoneImpl implements ApplePhone {
      5.   @Override
      6.   public void appleHeadset() {
      7.       System.out.println("[类适配器]使用了耳机适配器");
      8.       androidHeadset();
      9.   }
      10.   @Override
      11.   public void appleCharger() {
      12.       System.out.println("[类适配器]使用了充电器适配器");
      13.       androidCharger();
      14.   }
      15. }

    【对象适配器模式】

    1. /**
    2.  * 对象适配器
    3.  */
    4. public class ObjectAdapter implements ApplePhone {
    6.     private AndroidPhone androidPhone;
    8.     public ObjectAdapter(AndroidPhone androidPhone) {
    9.         this.androidPhone = androidPhone;
    10.     }
    11.     @Override
    12.     public void appleHeadset() {
    13.         System.out.println("[对象适配器]使用了耳机适配器");
    14.         androidPhone.androidHeadset();
    15.     }
    16.     @Override
    17.     public void appleCharger() {
    18.         System.out.println("[对象适配器]使用了耳机适配器");
    19.         androidPhone.androidCharger();
    20.     }
    21. }

    【默认适配器模式】

    1. /**
    2.  * 默认适配器（接口适配器/缺省适配器）
    3.  */
    4. public abstract class AbstractDefaultAdapter implements ApplePhone {
    5.     @Override
    6.     public void appleHeadset() { }
    7.     @Override
    8.     public void appleCharger() { }
    9. }
    1. /**
    2.  * 默认适配器实现类
    3.  */
    4. public class DefaultAdapter extends AbstractDefaultAdapter {
    5.     @Override
    6.     public void appleHeadset() {
    7.         System.out.println("[默认适配器]只适配了耳机");
    8.     }
    9. }
    1. public class AdapterTest {
    2.     public static void main(String[] args) {
    3.         // 类适配器
    4.         ApplePhone classAdapter = new ClassAdapter();
    5.         classAdapter.appleHeadset();
    6.         classAdapter.appleCharger();
    8.         System.out.println();
    10.         // 对象适配器
    11.         ApplePhone objectAdapter = new ObjectAdapter(new AndroidPhoneImpl());
    12.         objectAdapter.appleHeadset();
    13.         objectAdapter.appleCharger();
    15.         System.out.println();
    17.         // 默认适配器
    18.         ApplePhone defaultAdapter = new DefaultAdapter();
    19.         defaultAdapter.appleHeadset();
    20.         defaultAdapter.appleCharger();
    21.     }
    22. }
    23. ----输出----
    24. [类适配器]使用了耳机适配器
    25. 安卓耳机
    26. [类适配器]使用了充电器适配器
    27. 安卓充电器
    29. [对象适配器]使用了耳机适配器
    30. 安卓耳机
    31. [对象适配器]使用了耳机适配器
    32. 安卓充电器
    34. [默认适配器]只适配了耳机