【Java设计模式】七、适配器模式_java适配器模式实现

1、适配器模式

三孔插座上插两孔插头，不能直接插，中间可加个适配器，适配器一头可对接三孔插座，一头可对外提供两孔入口。适配器内部实现电流的处理和转换。

• 适配器模式Adapter Pattern，是做为两个不兼容的接口之间的桥梁
• 目的是将一个接口转换成客户希望的另外一个接口
• 适配器模式可以使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

适配器模式的角色：

• 目标接口：两块插座，可以是抽象类或接口
• 适配者类：三孔插座，待适配的类
• 适配器类：转换器，继承或者引用三孔插座对象，并把它转换成目标接口，让客户按目标接口的格式访问适配者

适配器模式的实现方式：定义一个适配器类来实现目标接口，同时继承或聚合现有的待适配的类

最后，适配器是对已经开发完的系统的一种改造思路，新设计尽量一次设计好，或者时间充裕就重构。适配器太多会使得系统很乱，看着在调A接口，底下已被适配到了B接口。

2、案例

有电脑只能读取SD卡，现在要读TF卡的信息，中间就得插个适配器。

先写待适配的类：

//TF卡接口
public interface TFCard {
    //读取TF卡
    String readTF();
    //写入TF卡
    void writeTF(String msg);
}

//TF卡实现类
public class TFCardImpl implements TFCard {

    public String readTF() {
        String msg ="tf card read msg : hello word tf card";
        return msg;
    }

    public void writeTF(String msg) {
        System.out.println("tf card write a msg : " + msg);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

准备目标接口：

//SD卡的接口
public interface SDCard {
    //读取SD卡方法
    String readSD();
    //写入SD卡功能
    void writeSD(String msg);
}

//SD卡实现类
public class SDCardImpl implements SDCard {
    public String readSD() {
        String msg = "sd card read a msg :hello word SD";
        return msg;
    }

    public void writeSD(String msg) {
        System.out.println("sd card write msg : " + msg);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

准备电脑类，代表客户客户的希望（或者说我们改造的目标），即希望用SDCard的接口读取SD和TF卡：

//电脑类
public class Computer {

    public String readSD(SDCard sdCard) {
        if(sdCard == null) {
            throw new NullPointerException("sd card null");
        }
        return sdCard.readSD();
    }
}
1
2
3
4
5
6
7
8
9
10

定义测试类，看原有功能读取SD卡内容是否正常：

//测试类
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        SDCard sdCard = new SDCardImpl();
        System.out.println(computer.readSD(sdCard));
    }
}
1
2
3
4
5
6
7
8

输出：

sd card read a msg :hello word SD
1

实现方式一：类适配器

接下来为了让电脑能读TF卡，开始开发适配器类，操作是：实现目标接口，继承待适配的类：

//定义适配器类（SD兼容TF）
public class SDAdapterTF extends TFCardImpl implements SDCard {

	@Override
    public String readSD() {
        System.out.println("adapter read tf card ");
        return readTF();  //实际还是从TF读取
    }

	@Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        writeTF(msg);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

到此，TF这个"两孔插头"就可以插"三孔插座"上了

//测试类
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        SDAdapterTF adapter = new SDAdapterTF();
        System.out.println(computer.readSD(adapter));
    }
}
1
2
3
4
5
6
7
8

以上，目标类没有接口时，不可用了

实现方式二：对象适配器

创建对象适配器，让适配器类实现目标接口，聚合待适配的类

//创建适配器对象（SD兼容TF）
public class SDAdapterTF  implements SDCard {

    private TFCard tfCard;    //聚合待适配的类

    public SDAdapterTF(TFCard tfCard) {   //只留一个有参构造
        this.tfCard = tfCard;
    }

	@Override
    public String readSD() {
        System.out.println("adapter read tf card ");
        return tfCard.readTF();
    }

	@Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(msg);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

测试：

//测试类
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        TFCard tfCard = new TFCardImpl();
        SDAdapterTF adapter = new SDAdapterTF(tfCard);     //适配器类对象
        System.out.println(computer.readSD(adapter));
    }
}
1
2
3
4
5
6
7
8
9

适配器类之所以总是实现（或者继承）原有的类，是因为其一端要能插进电脑的SD入口，即要保证其是SD入口这一端的子类。

最后，当不希望实现一个接口中的所有方法时，可以创建一个抽象类Adapter，实现其他方法，留下要重写的那部分方法给未来的子类去实现（抽象类是半抽象的），后面的子类直接继承这个抽象类即可。

3、源码中的实际应用

JDK中，Reader字符流和InputStream字节流适配，用到了InputStreamReader将字节流转换为字符流，其继承了Reader这个目标类

类图如上，其实适配器是StreamDecoder这个流解码器类，但它不是Java SE的API