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

类适配器

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

电源适配器：

220V：

public class Voltage220V {
    public int output220V(){
        int src=220;
        System.out.println(src);
        return src;
    }
}

1
2
3
4
5
6
7
8

5V：

public interface Voltage5V {
    public int output5V();
}

1
2
3
4

适配器：

public class VoltageAdapter extends Voltage220V implements Voltage5V {
    @Override
    public int output5V() {
        //获取220V电压
        int src=super.output220V();
        int dstV=src/44;
        return dstV;
    }
}
1
2
3
4
5
6
7
8
9
10

Phone

public class Phone {
    public void charging(Voltage5V voltage5V){
        if(voltage5V.output5V()==5){
            System.out.println("电压5v");
        }else if(voltage5V.output5V()>5){
            System.out.println("电压过高");
        }
    }
}

1
2
3
4
5
6
7
8
9
10

客户端：

public class AdapterClient {
    public static void main(String[] args) {
        System.out.println("类适配器");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

1
2
3
4
5
6
7
8

对象适配器

1.基本思路和类的适配器模式相同，但是将Adapter类做修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。即：持有src类，实现dst类接口，完成src-》dst的适配
2.根据合成复用原则，在系统中尽量使用关联关系来代替继承关系
3.对象适配器模式是适配器模式常用的一种

例子：充电器，冲前期本身相当于adapter，220V交流电相当于src（即被适配者），我们的目的dst是5V，使用对象适配器模式完成

Phone. Voltage5V 和 Voltage220V 与类适配器相同

VoltageAdapter：

public class VoltageAdapter implements Voltage5V {
    private Voltage220V voltage220V;
    public VoltageAdapter(){

    }

    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
         int dst=0;
         if(null!=voltage220V){
             int src=voltage220V.output220V();
             System.out.println("使用对象适配器");
             dst=src/44;
             System.out.println("适配完成 ");
         }
        return dst;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

CLient此时需要在new VoltageAdapter时传入一个Voltage220v 因此client此时也与Voltage220v发生依赖关系

public class AdapterClient {
    public static void main(String[] args) {
        System.out.println("对象适配器");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

1
2
3
4
5
6
7
8

接口适配器模式（缺省适配器模式）

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

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

接口

public interface myInterface2 {
    public void m1();
    public void m2();
    public void m3();
    public void m4();
}

1
2
3
4
5
6
7

抽象类实现接口

public abstract class AbsAdapter implements myInterface2 {
    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Client调用

public class interfaceAdapterClient {
    public static void main(String[] args) {
        //只需覆盖需要使用的接口方法
        AbsAdapter absAdapter=new AbsAdapter() {
            @Override
            public void m1() {
                super.m1();
            }
        };
        absAdapter.m1();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

适配器模式在MVC中的应用

SpringMVC中的HandlerAdapter就使用了适配器模式
太复杂算了

注意事项和细节

类适配器：以类给到，在Adapter里，就是将src当作类，继承
对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有
接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作
实际开发中，实现起来不拘泥于三种经典形式