设计模式演化之适配器模式

定义

将一个类的调用接口转换成另一个接口，使得由于接口不兼容的类可以一起工作

演化

1.给手机充电，一般家用电是220V。

public class PowerSource {
    private int voltage = 220;
    
    public int output() {
        System.out.println("输出电压: " + voltage + "V");
        return voltage;
    } 
}

2.而手机一般用的是5V，我们可以直接修改Mobile类，让它能将220V的电压转换为5V

public class Mobile {
    
    private PowerSource source;

    public Mobile(PowerSource source) {
        this.source = source;
    }
    
    public void input() {
        int voltage = source.output() / 44;
        System.out.println("正在充电，电压为: " + voltage + "V");
    }
}

这个写法已经可以把220V的电压转化成5V了，看起来并不需要适配啊！但这种写法依然存在不足之处

• 从实际意义上讲，Mobile已经是成品类，不能修改
• 如果还存在一个别的可充电设备Watch，它也用5V的电。按这种写法，还要修改Watch类。
• Mobile在定义时，还需要考虑电源的电压，且定义之后难以修改。

3.为了解决2中的问题，我们需要一个中间类，它具备以下特点

• 可以修改，这意味着它应该由调用方定义
• 可以对多种可充电设备充电，就需要持有多个充电设备的统一接口
• 可以用在不同电压的电源上，需要电源维护一个统一的接口，且中间类的转换规则是可变的

(1) 定义可充电设备的统一接口

public interface Charge {
    void input(int voltage);
}

(2) 重新定义Mobile类

public class Mobile implements Charge {

    @Override
    public void input(int voltage) {
        System.out.println("正在充电: " + voltage + "V");
    }
}

(3) 定义电源统一接口

public interface Power {
    int output();
}

(4) 重新定义电源类

public class PowerSource implements Power{

    @Override
    public int output() {
        int voltage = 220;
        System.out.println("输出电压: " + voltage + "V");
        return voltage;
    }
}

(5) 建立电源与Mobile的适配规则

public class PowerAdapter {

    private Charge charge;
    private Power power;
    private int count;

    public PowerAdapter(Charge charge, Power power, int count) {
        this.charge = charge;
        this.power = power;
        this.count = count;
    }

    public void start() {
        int voltage = power.output() / count;
        charge.input(voltage);
    }
}

此时，我们可以任意定义电源与可充电设备，且不需要考虑电压的问题。通过这种适配器，可以将原本不相容的两个类放在一起工作了。

注意

从写法上讲，适配器模式与桥接模式几乎一模一样。但二者之间还是存在着本质的区别的。
(1) 适配器模式是为了让不兼容的接口能一起工作，它的作用范围在两个不兼容的接口之间，是对内的。而桥接模式是将两个不同纬度的属性连接成一个整体，然后再对外提供功能。
(2) 适配器模式是先有接口，后有连接规则。桥接模式是先有连接规则，后有被连接的类。
(3) 适配器模式的目的是兼容不能修改的接口实现。而桥接模式相反，先将原本可以写在一起的功能拆开，使得他们能独立变换，然后再连接起来，整体使用。