设计模式之适配器模式

适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接二者，将不匹配变得匹配，简单点理解就是平常所见的转接头，转换器之类的存在。

适配器模式有两种：类适配器、对象适配器、接口适配器

前二者在实现上有些许区别，作用一样，第三个接口适配器差别较大。
直接上代码:
父接口SuperA和SuperB：

package com.my.adapterDemo;

public interface SuperA {
    String sayA();

    String sayA1();

    String sayA2();

}

package com.my.adapterDemo;

public interface SuperB {

    String sayB();

    String sayB1();

    String sayB3();
}

第一种适配器模式：类适配器

package com.my.adapterDemo;

public class B implements  SuperB{
    @Override
    public String sayB() {
        System.out.println("sayB");
        return "sayB";
    }

    @Override
    public String sayB1() {
        System.out.println("sayB");
        return "sayB1";
    }

    @Override
    public String sayB3() {
        System.out.println("sayB");
        return "sayB3";
    }
}

package com.my.adapterDemo;
/*
* 最简单的适配器模式：类适配器*/
public class A extends B implements SuperA {
    @Override
    public String sayA() {
        System.out.println("sayA");
        return "sayA";
    }

    @Override
    public String sayB3() {
        return super.sayB3();
    }

    /*继承了SuperB的实现类B，也就可以使用SUperB中的方法，实现了适配器
     */
    @Override
    public String sayA1() {
        System.out.println("sayA1");
        return "sayA1";
    }

    @Override
    public String sayA2() {
        System.out.println("sayA2");
        return "sayA1";
    }

    public static void main(String[] args) {
        new A().sayB3();
    }
}

第二种：对象适配器

package com.my.adapterDemo;
/*
第二种适配器模式：对象适配器模式
通过在A1中实现A接口，将SuperB作为成员变量，
并在构造时初始化B，即可调用SUperB中的方法。
 */
public class A1 implements SuperA {
    private SuperB b;

    public A1(SuperB b){
       this.b = b;
    }

    @Override
    public String sayA() {
        return null;
    }

    @Override
    public String sayA1() {
        return null;
    }

    @Override
    public String sayA2() {
        return null;
    }

    public static void main(String[] args) {
//        获得适配器B的对象
        SuperB b = new B();
//        实例化A1时装载b对象，获得b对象调用b对象的方法
        new A1(b).b.sayB();
    }
}

第三种：接口适配器
不需要用B去继承了，换成了AbstractB，一个抽象类：

package com.my.adapterDemo;
/*
采用抽象类实现接口，且实现接口中的所有中方法，
这样子类A3可以灵活得选取要使用SuperB中的方法，只要重写AbstractB中的一个或多个方法
 */
public abstract class AbstractB implements SuperB {
    @Override
    public String sayB() {
        System.out.println("abstratB.sayB()");
        return null;
    }

    @Override
    public String sayB3() {
        return null;
    }

    @Override
    public String sayB1() {
        return null;
    }

    public static void main(String[] args) {
        //AbstractB b = new
    }
}

package com.my.adapterDemo;
/*
* 同A、A1差不多，只是继承AbstractB，这样就不需要重写所有方法，可以灵活选取
* */
public class A3 extends AbstractB implements SuperA {

    public static void main(String[] args) {
        new A3().sayB();//会去调用父类AbstractB的方法
    }

    @Override
    public String sayA() {
        return null;
    }



    @Override
    public String sayA1() {
        return null;
    }

    @Override
    public String sayA2() {
        return null;
    }


}