设计模式：Adapter--适配器模式

适配器模式：

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

1 类适配器：核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口是Targetable，通过Adapter类，将Source的功能扩展到

 

2 对象适配器：基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

3 接口适配器：

第三种适配器模式是接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图：

类适配器是其他的基础

讲了这么多，总结一下三种适配器模式的应用场景：

类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

简易代码实现：类和对象适配器

public class Current {

    public void use220V() {
        System.out.println("使用220v的电流");
    }
}
**************************************************************
/**
 * 使用继承的方式实现适配器
 */

public class Adapter extends Current {

    public void use18V() {
        System.out.println("使用适配器adapter");
        this.use220V();
    }
}

**************************************************************
/**
 * 使用委让的形式实现
 */
public class Adapter2 {

    private Current current;

    public Adapter2(Current current) {
        this.current = current;
    }

    public Current getCurrent() {
        return current;
    }

    public void setCurrent(Current current) {
        this.current = current;
    }

    public void user18V(){
        System.out.println("使用适配器Adapter2");
        current.use220V();
    }
}

**************************************************************

public class MailClass {
    public static void main(String[] args) {
        Current current = new Current();
        current.use220V();

        System.out.println("*******************************");
        Adapter adapter = new Adapter();
        adapter.use18V();

        System.out.println("*******************************");

        Adapter2 adapter2 = new Adapter2(current);
        adapter2.user18V();
    }
}

测试结果
使用220v的电流
*******************************

使用适配器adapter
使用220v的电流

*******************************
使用适配器Adapter2
使用220v的电流

 

 

***类适配器：

public class Adaptee {

    public void sampleOperation1(){
        System.out.println("this is original method!");
    }
}
****************************************************************************************************************

/**
 * 上面给出的是目标角色的源代码，这个角色是以一个Java接口的形式实现的。可以看出，这个接口声明了两个方法：sampleOperation1()和sampleOperation2()。
 * 而源角色Adaptee是一个具体类，它有一个sampleOperation1()方法，但是没有sampleOperation2()方法。
 *
 * 适配器角色Adapter扩展了Adaptee,同时又实现了目标(Target)接口。
 * 由于Adaptee没有提供sampleOperation2()方法，而目标接口又要求这个方法，因此适配器角色Adapter实现了这个方法。
 */

public class Adapter extends Adaptee implements Target {

    @Override
    public void sampleOperation2() {
        System.out.println("this is the Target method!");
    }
}
****************************************************************************************************************

/**
 * 类适配器模式：
 *
 * 用电器做例子，笔记本电脑的插头一般都是三相的，即除了阳极、阴极外，还有一个地极。而有些地方的电源插座却只有两极，没有地极。
 * 电源插座与笔记本电脑的电源插头不匹配使得笔记本电脑无法使用。
 * 这时候一个三相到两相的转换器（适配器）就能解决此问题，而这正像是本模式所做的事情。
 *
 * Adaptee类并没有sampleOperation2()方法，而客户端则期待这个方法。为使客户端能够使用Adaptee类，提供一个中间环节，即类Adapter，把Adaptee的API与Target类的API衔接起来。
 * Adapter与Adaptee是继承关系，这决定了这个适配器模式是类的：
 *
 * 目标(Target)角色：这就是所期待得到的接口。注意：由于这里讨论的是类适配器模式，因此目标不可以是类。
 * 源(Adapee)角色：现在需要适配的接口。
 * 适配器(Adaper)角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。显然，这一角色不可以是接口，而必须是具体类。
 *
 */
public interface Target {

    //这个是源类Adaptee也有的方法
    public void sampleOperation1();
    //这是源类Adapteee没有的方法
    public void sampleOperation2();
}

****************************************************************************************************************

public class MainClass {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.sampleOperation1();
        target.sampleOperation2();
    }
}


测试结果：
this is original method!
this is the Target method!

 

2 对象适配器

 

/**
 * 对象适配器模式：
 *
 *
 *
 * Adaptee类并没有sampleOperation2()方法，而客户端则期待这个方法。
 * 为使客户端能够使用Adaptee类，需要提供一个包装(Wrapper)类Adapter。
 * 这个包装类包装了一个Adaptee的实例，从而此包装类能够把Adaptee的API与Target类的API衔接起来。
 * Adapter与Adaptee是委派关系，这决定了适配器模式是对象的。
 */
interface Target {
    /**
     * 这是源类Adaptee也有的方法
     */
    public void sampleOperation1();
    /**
     * 这是源类Adapteee没有的方法
     */
    public void sampleOperation2();
}

class Adaptee {
    public void sampleOperation1(){
        System.out.println("this is original method!");
    }
}

class Adapter implements Target{
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public Adaptee getAdaptee() {
        return adaptee;
    }

    public void setAdaptee(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void sampleOperation1() {
        adaptee.sampleOperation1();
    }

    @Override
    public void sampleOperation2() {
        System.out.println("this is the targetable method!");
    }
}

public class MainClass {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.sampleOperation1();
        target.sampleOperation2();

    }
}

测试结果：
this is original method!
this is the targetable method!

 

 

3 接口适配器 

/**
 * 接口的适配器模式，
 *
 * 接口的适配器是这样的：
 * 有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，
 * 这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，
 * 我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，
 * 所以我们写一个类，继承该抽象类，重写我们需要的方法就行
 */
interface Sourceable {
    public void method1();
    public void method2();
}


abstract class  Wrapper implements  Sourceable {
    @Override
    public void method1() {}

    @Override
    public void method2() {}
}

class SourceSub1 extends  Wrapper {
    @Override
    public void method1() {
//        super.method1();
        System.out.println("the sourceable interface's first Sub1!");
    }
}

class SourceSub2 extends Wrapper {
    @Override
    public void method2() {
//        super.method2();
        System.out.println("the sourceable interface's second Sub2!");
    }

}
public class MainClass {
    public static void main(String[] args) {
        Sourceable source1 = new SourceSub1();
        Sourceable source2 = new SourceSub2();

        source1.method1();
        source1.method2();//这个方法里面没有实现，所以不会输出
        System.out.println("****************");
        source2.method1();//这个方法里面没有实现，所以不会输出
        source2.method2();
    }
}

测试：
the sourceable interface's first Sub1!
****************
the sourceable interface's second Sub2!