设计模式-适配器模式

适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能

• 将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
• 适配器模式分为: 类适配器 和 对象适配器 和 接口适配器。前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少。

适配器模式（Adapter）包含以下主要角色:

• 目标（Target）接口: 当前系统业务所期待的接口，它可以是抽象类或接口
• 适配者（Adaptee）类: 它是被访问和适配的现存组件库中的组件接口
• 适配器（Adapter）类: 它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

应用场景:

• 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致
• 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同

类适配器

UML类图:

1、定义适配者接口与实现类:

public interface TFCard {
    /**
     * 读取 TF卡
     * @return String msg
     */
    public String readTF();

    /**
     * 写TF卡
     */
    public void writeTF();
}

public class TFCardImpl implements TFCard {
    @Override
    public String readTF() {
        String msg = "正在读取TF卡....";
        return msg;
    }

    @Override
    public void writeTF() {
        System.out.println("正在写入TF卡....");
    }
}

2、定义目标接口与实现类:

public interface SDCard {
    /**
     * 读取 SD卡
     * @return String msg
     */
    public String readSD();

    /**
     * 写 SD卡
     */
    public void writeSD();
}

public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        String msg = "正在读取SD卡....";
        return msg;
    }

    @Override
    public void writeSD() {
        System.out.println("正在写入SD卡....");
    }
}

3、定义Computer类:

public class Computer {
    // 从SD卡中读取数据
    public String readSD(SDCard sdCard) {
        if (sdCard == null) {
            throw new NullPointerException("SD卡不能为空!");
        }
        return sdCard.readSD();
    }
}

4、定义适配器:

public class SDAdapterTF extends TFCardImpl implements SDCard {
    @Override
    public String readSD() {
        System.out.println("适配器正在从TF卡中读取数据");
        return super.readTF();   // readTF()
    }

    @Override
    public void writeSD() {
        System.out.println("适配器正在写入TF卡");
        super.writeTF();   // writeTF()
    }
}

5、定义客户端类:

public class Client {
    public static void main(String[] args) {
        // 创建 Computer对象
        Computer computer = new Computer();
        // 使用适配器读取 TF卡中的数据
        String msg = computer.readSD(new SDAdapterTF());
        System.out.println(msg);
    }
}

类适配器模式违背了合成复用原则。类适配器只适用于客户类有一个接口规范的情况下，如果目标接口没有定义这个接口，而仅仅是一个实现类则不可用。因为在 Java中类是单继承的。

对象适配器

UML类图:

根据上述的实现，只需要更改一下适配器类和客户端类即可

public class SDAdapterTF implements SDCard {
    private TFCard tfCard;

    // 通过构造方法注入
    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("适配器正在从TF卡中读取数据");
        return tfCard.readTF();
    }

    @Override
    public void writeSD() {
        System.out.println("适配器正在写入TF卡");
        tfCard.writeTF();
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建 Computer对象
        Computer computer = new Computer();
        // 使用适配器读取 TF卡中的数据
        String msg = computer.readSD(new SDAdapterTF(new TFCardImpl()));
        System.out.println(msg);
    }
}

对象适配器并不要求客户类必须有这个接口规范，即使没有也可以去使用它

接口适配器

还有一种适配器模式: 接口适配器模式。当不希望实现一个接口中的所有方法时，可以创建一个抽象类Adapter，实现所有方法。而我们只需要去继承它即可。

public interface SDCard {
    /**
     * 读取 SD卡
     * @return String msg
     */
    public String readSD();

    /**
     * 写 SD卡
     */
    public void writeSD();

    /**
     * 关于SD卡的自我修养(无用的接口)
     */
    public void show();
}

public abstract class Adapter implements SDCard{
    @Override
    public String readSD() {
        return null;
    }

    @Override
    public void writeSD() { }

    @Override
    public void show() { }
}

public class SDAdapterTF extends Adapter {

    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("适配器正在从TF卡中读取数据");
        return tfCard.readTF();
    }

    @Override
    public void writeSD() {
        System.out.println("适配器正在写入TF卡");
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建 Computer对象
        Computer computer = new Computer();
        // 使用适配器读取 TF卡中的数据
        String msg = computer.readSD(new SDAdapterTF(new TFCardImpl()));
        System.out.println(msg);
    }
}

在JDK中的应用

Reader(字符流) 与 InputStream(字节流) 的适配使用的是InputStreamReader

而InputStreamReader继承自java.io包中的Reader，对它中的抽象方法给出实现:

public int read() throws IOException {
    return sd.read;
}

public int read(char cbuf[], int offset, int length) throws IOExcetion {
    return sd.read(cbuf, offset, length);
}

上面代码中的sd是StreamDecoder对象 （StreamDecoder做的是流的解码操作，解码是将字节数据转换成字符数据，编码是将字符数据转换成字节数据），在Sun的JDK实现中，实际的方法是对sun.nio.cs.StreamDecoder类的同名方法的调用封装。类结构如下:

可以得出结论:

• InputStreamReader是对同样实现了Reader的StreamDecoder的封装
• StreamDecoder不是 Java SE API中的内容，是 Sun JDK自己给出的实现。但我们知道他们对构造方法中的字节流类InputStream进行了封装，并通过该类进行了字节流和字符流之间的解码转换
• 从表层来看InputStreamReader做了InputStream字节流类到Reader字符流之间的转换。从类结构可以看出，StreamDecoder的设计实现采用了适配器模式