【Java随笔】适配器设计模式：起转接口的作用

应用1：当接口A作为方法a(A)的参数时，接口A被弃用，新建接口B，此时在不改变方法a(A)的情况下，怎么继续使用。
解决方法：通过接口A的适配器实现类，传递接口B

public class Test13 {
    /*适配器设计模式：将一个类的接口转换成另一个接口。（解决接口不兼容问题）A接口对接B接口，但是无法绑定，此时需要转接口C,将A、B连接起来。
    * 1.接口A，实现类AImpl
    * 2.运行时，使用方法work(A)。（绑定接口A作为参数）
    * 3.接口B，实现类BImpl
    * 问题：怎么让接口B作为方法work()的参数
    * 4.创建接口A的适配器实现类:将接口B作为私有属性，重写方法中调用接口B方法
    * 5.运行时，适配器类
    * */
    public static void main(String[] args) {
        PowerA powerA = new PowerAImpl();
        work(powerA);//2.运行时，使用方法work(A)。（绑定接口A作为参数）()
        PowerB powerB = new PowerBImpl();
        Adapter adapter = new Adapter(powerB);//5.运行时，适配器类
        work(adapter);
    }
    //2.运行时，使用方法work(A)。（绑定接口A作为参数）
    public static void work(PowerA a){//当接口A不用，改用接口B时，怎么操作
        System.out.println("正在连接。。。");
        a.insert();
        System.out.println("工作结束。。。。");
    }
}
//4.创建接口A的适配器实现类:将接口B作为私有属性，重写方法中调用接口B方法
class Adapter implements PowerA{
    private PowerB powerB;
    public Adapter(PowerB powerB){
        this.powerB = powerB;
    }
    public void insert(){
        powerB.connect();
    }
}
//3.接口B
interface PowerB{
    public void connect();
}
//3.接口B的实现类BImpl，重写方法
class PowerBImpl implements PowerB{
    public void connect(){
        System.out.println("PowerB开始工作。。。。");
    }
}
//1.接口A
interface PowerA{
    public void insert();
}
//1.接口A的实现类AImpl，重写方法
class PowerAImpl implements PowerA{
    public void insert(){
        System.out.println("电源A开始工作");
    }
}

应用2：接口有很多方法，但实现类不想全部重写其方法时。
解决办法：通过抽象类实现接口所有方法，实现类继承抽象类。

public class Test14 {
    /*适配器设计模式：接口的实现类必须实现接口所有的方法，此时可以用一个抽象类先实现接口，具体实现类继承抽象类。
    * 1.接口
    * 2.抽象类实现接口，空方法
    * 3.具体实现类继承抽象类，此时不用实现接口的所有方法
    * */
    public static void main(String[] args) {
        Dog1 dog1 = new Dog1();
        dog1.run();
    }
}
//1.接口
interface Animal{
    public void sing();
    public void cry();
    public void run();
    public void swim();
}
//2.抽象类实现接口，空方法
abstract class AnimalFunction implements Animal{
    @Override
    public void sing() {}

    @Override
    public void cry() {}

    @Override
    public void run() {}

    @Override
    public void swim() {}
}
//3.具体实现类继承抽象类，此时不用实现接口的所有方法
class Dog1 extends AnimalFunction{
    @Override
    public void run() {
        System.out.println("我是疯狗，我疯狂的跑");
    }

}