适配器模式

1. 类适配器模式
角色：

1. 被适配的类
2. 适配接口
3. 适配器（继承上面两个，实现适配接口的方法，在方法中，得到被适配类的成果，把成果做相应的转换，然后输出成果）
4. 使用者类

场景： 手机充电时候，不能直接冲220V的电，必须室友充电器抓换成5V，这里面

1. 被适配的类（220V的电）
2. 适配接口（5V的电， 里面定义一个转换方法）
3. 适配器（在方法中拿到220V，转换成5V，然后返回）
4. 使用者类（手机， 直接使用适配器类进行充电）

代码：

public class SingleFantasy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

//被适配的类
class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("原始电压=" + src);
        return src;
    }
}
//适配接口
interface IVoltage5V{
    //输出5V的电压
    public int output5V();
}

//适配器类
class VoltageAdapter extends Voltage220V implements IVoltage5V{

    @Override
    public int output5V() {
        int srcV = output220V();
        int dstV = srcV / 44;
        return dstV;
    }
}
//使用
class Phone{
    public void charging(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V() == 5){
            System.out.println("电压为5V， 开始充电");
        }else if(iVoltage5V.output5V() > 5){
            System.out.println("电压大于5V， 不能充电");
        }
    }
}

2. 对象适配器模式
根据尽量使用对象组合而不是类继承的原则， 我们不继承被适配的对象， 而是采用关联的关系来代替继承。

public class SingleFantasy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

//被适配的类
class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("原始电压=" + src);
        return src;
    }
}
//适配接口
interface IVoltage5V{
    //输出5V的电压
    public int output5V();
}

//适配器类
class VoltageAdapter  implements IVoltage5V{

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

    @Override
    public int output5V() {
        int srcV = voltage220V.output220V();//这里通过传入的对象获取被适配的电压
        int dstV = srcV / 44;
        return dstV;
    }
}
//使用
class Phone{
    public void charging(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V() == 5){
            System.out.println("电压为5V， 开始充电");
        }else if(iVoltage5V.output5V() > 5){
            System.out.println("电压大于5V， 不能充电");
        }
    }
}

3. 接口适配器模式

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

public class SingleFantasy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

//被适配的类
class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("原始电压=" + src);
        return src;
    }
}

//适配接口
interface IVoltage5V {
    //输出5V的电压
    public int output2V();
    public int output5V();
    public int output10V();
    public int output20V();

}
//把接口的方法默认实现
abstract class absAdapter implements IVoltage5V {

    @Override
    public int output2V() {
        return 0;
    }

    @Override
    public int output5V() {
        return 0;
    }

    @Override
    public int output10V() {
        return 0;
    }

    @Override
    public int output20V() {
        return 0;
    }
}

//适配器类 只需要覆盖我们关心的那些方法
class VoltageAdapter extends absAdapter {

    private Voltage220V voltage220V;

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

    @Override
    public int output5V() {
        int srcV = voltage220V.output220V();
        int dstV = srcV / 44;
        return dstV;
    }
}

//使用
class Phone {
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压为5V， 开始充电");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V， 不能充电");
        }
    }
}