适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。允许通常因为接口不兼容而不能在一起工作的类工作在一起

类适配器：

类适配器的3个角色：

目标（Target）接口：当前系统业务所期待的接口（或抽象类）

适配者（Adaptee）类：被适配的角色，定义一个接口，需要适配器才能工作

适配器（Adapter）类：适配器可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，通过继承Target并关联一个Adaptee对象使二者产生联系。

（由于Java不支持多继承，所以要把Target定义成接口）

Cast1：家用电压为220V，而手机充电电压一般为5V，通过手机充电器降压使得手机可以充电

家用电类（Target）： 

1 public class HouseholdVoltage {
2     private final int Voltage = 220;
3 
4     public int output() {
5         System.out.println("家用电压220V");
6         return Voltage;
7     }
8 }

View Code

充电接口（Adaptee）：

1 interface ICharger {
2     public int getVoltage();
3 }

View Code

充电适配器（Adapter）：

public class VoltageAdapter extends HouseholdVoltage implements ICharger {
    @Override
    public int getVoltage() {
        int srcV = output();
        System.out.println("充电器降压");
        int destV = srcV / 44;  // 通过变压器降压
        return destV;
    }
}

View Code

手机：

1 public class Phone {
2     public void charging(ICharger iCharger) {
3         if(iCharger.getVoltage() == 5) {
4             System.out.println("充电中...");
5             return;
6         }
7         System.out.println("电压过大!!!");
8     }
9 }

View Code

client（Main）：

1 public class Main {
2     public static void main(String[] args) {
3         Phone phone = new Phone();
4         phone.charging(new VoltageAdapter());
5     }
6 }

View Code

对象适配器：

基本和类适配器相同，只是修改 Adapter,不继承Adaptee，而是采用聚合的方式，符合合成复用原则（对象适配器模式是适配器模式常用的一一种）

 Adapter修改：

1 public class VoltageAdapter implements ICharger {
2     private HouseholdVoltage volt = new HouseholdVoltage();
3 
4     @Override
5     public int getVoltage() {
6         return volt.output() / 44;
7     }
8 }

接口适配器（缺省适配器）：

当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现(空方法)，那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求，JDK1.8以后接口可以定义default方法，可以省略这个抽象类

Cast3：

DefaultAdapter：

 1 public abstract class DefaultAdapter implements Inter {
 2     @Override
 3     public void fun1() {}
 4 
 5     @Override
 6     public void fun2() {}
 7 
 8     @Override
 9     public void fun3() {}
10 }

View Code

Interface：

1 public interface Inter {
2     void fun1();
3 
4     void fun2();
5 
6     void fun3();
7 }

View Code

Main：只实现fun2

 1 public class Main {
 2     public static void main(String[] args) {
 3         DefaultAdapter defaultAdapter = new DefaultAdapter() {
 4             @Override
 5             public void fun2() {
 6                 System.out.println("invoke fun2()");
 7             }
 8         };
 9         defaultAdapter.fun2();
10     }
11 }

View Code

Cast3.2

省略DefaultAdapter，将Interface的方法改为default方法

Interface：

1 public interface Inter {
2     default void fun1() {}
3 
4     default void fun2() {}
5 
6     default void fun3() {}
7 }

View Code

Main：

 1 public class Main {
 2     public static void main(String[] args) {
 3         Inter inter = new Inter() {
 4             @Override
 5             public void fun2() {
 6                 System.out.println("invoke fun2()");
 7             }
 8         };
 9         inter.fun2();
10     }
11 }

View Code