JAVA设计模式之——适配器模式

---

一、类型

结构型模式

---

二、定义

将某个类的接口转换成客户端期望的另一个接口，让原本因为接口不匹配而不能工作的类可以一起协同工作。

适配器模式一共分为3种

• 类适配器模式
• 对象适配器模式
• 接口适配器模式

---

三、举例

我们的家用电都是 220V，但是手机这种小型设备充电的时候无法使用 220V，它只需很低的电压即可，例如 5V，我们可以使用适配器模式，将 220V 电压转换成 5V 电压。

---

四、类适配器模式

4.1 定义

一个 Adapter 类，通过继承 Source 类，实现 Target (目标)接口，完成 Source -> Target 的转换。

4.2 参与者

1、Source：一个已存在的类，需要对其进行适配
2、Target：转换的目标接口
3、Adapter：继承 Source 类，实现 Target 接口，并对其进行适配
4、Client：客户端，和 Target 接口协同

4.3 UML类图

4.4 示例代码

• Source类：需要适配的类

// 需要适配的类
public class Source {
    public int output220V() {
        int voltage = 220;
        System.out.println("原电压：" + voltage + "V");
        return voltage;
    }
}

• Target接口：适配的目标接口

// 适配的目标接口
public interface Target {
    int output5V();
}

• Adapter类：继承 Source 类，实现 Target 接口，并对它们进行适配

// 适配器类，对Source和Target进行适配
public class Adapter extends Source implements Target {
    @Override
    public int output5V() {
        int voltage = output220V() / 4;
        return voltage;
    }
}

• Client：客户端，和 Target 接口协同

public class Client {
    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        int voltage = adapter.output5V();
        System.out.println("转换后电压：" + voltage + "V");
    }
}

运行结果

原电压：220V
转换后电压：55V

4.5 注意事项和细节

• 因为 Java 是单继承的机制，所以适配器类 Adapter 继承了 Source 类后，就无法继承其它类了，有一定的局限性。
• 适配器类 Adapter 类继承 Source 类，导致 Source 类中所有的方法都会在 Adapter 中暴露出来。

---

五、对象适配器模式

5.1 定义

适配器类 Adapter 持有 Source 类的对象，实现 Target 接口，完成 Source->Target 的适配。

5.2 参与者

1、Source：一个已存在的类，需要对其进行适配
2、Target：适配的目标接口
3、Adapter：适配器类，对 Source 和 Target 进行适配
4、Client：客户端，和 Target 接口协同

5.3 UML类图

5.4 示例代码

• Source：一个已存在的类，需要对其进行适配

// 需要适配的类
public class Source {
    public int output220V() {
        int voltage = 220;
        System.out.println("原电压：" + voltage + "V");
        return voltage;
    }
}

• Target：适配的目标接口

// 适配的目标接口
public interface Target {
    int output5V();
}

• Adapter：持有 Source 类，实现 Target 接口，完成 Source->Target 的适配

// 适配器类，对Source和Target进行适配
public class Adapter implements Target {
    // 关联关系——聚合
    private Source source;

    public Adapter(Source source) {
        this.source = source;
    }

    @Override
    public int output5V() {
        int voltage = source.output220V() / 4;
        return voltage;
    }
}

• Client：客户端，和 Target 接口协同

public class Client {
    public static void main(String[] args) {
        Adapter adapter = new Adapter(new Source());
        int voltage = adapter.output5V();
        System.out.println("转换后电压：" + voltage + "V");
    }
}

执行结果：

原电压：220V
转换后电压：55V

5.5 注意事项和细节

• 对象适配器和类适配器思想相同，只是实现方式不同；
• 对象适配器符合合成复用原则，使用组合代替了继承。解决了类适配器必须继承 Source 的局限性。

---

六、接口适配器模式

6.1 定义

当不需要实现接口提供的全部方法时，可以先设计一个抽象类实现这个接口，并为接口的每个方法提供一个默认实现（空方法），然后这个抽象类的子类就可以有选择性的覆盖父类的某些方法，以此来实现某些需求。

6.2 参与者

1、InterfaceZ：要实现的接口
2、AbsAdapter：实现接口的抽象类，并为每个方法提供一个默认实现
3、ConcreteClass：抽象类的实现类，有选择性的覆盖有些方法

6.3 类图

6.4 示例代码

• InterfaceZ：我们要实现的接口

public interface InterfaceZ {
    void ope01();
    void ope02();
    void ope03();
    void ope04();
}

• AbsAdapter：实现接口的抽象类，并为每个方法提供一个默认实现

// 对接口中的方法提供一个默认实现
public abstract class AbsAdapter implements InterfaceZ {
    @Override
    public void ope01() {}

    @Override
    public void ope02() {}

    @Override
    public void ope03() {}

    @Override
    public void ope04() {}
}

• ConcreteClass：抽象类的实现类，有选择性的覆盖有些方法

// 只覆盖方法 ope01
public class A extends AbsAdapter {
    @Override
    public void ope01() {
        System.out.println("使用了 ‘ope01’ 方法");
    }
}

• Client：客户端

public class Client {
    public static void main(String[] args) {
        A a = new A();
        a.ope01();
    }
}

执行结果：

使用了 ‘ope01’ 方法

6.5 注意事项和细节

使用场景
适用于一个不想实现接口中全部方法的情况。

---

参考文章

• https://blog.csdn.net/l1028386804/article/details/45457903
• http://www.atguigu.com/download_detail.shtml?v=202