设计模式精讲系列：什么是适配器模式？什么需要被适配？

发表于 更新于 分类于 阅读次数： 本文字数： 3k 阅读时长 ≈ 3 分钟

你好，我是猿java。

这篇文章，我们继续分析设计模式的适配器模式

1. 什么是适配器模式

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许将一个接口转换成客户端所期望的另一种接口。适配器模式的核心思想是通过创建一个中间层（适配器），使得原本由于接口不兼容而无法一起工作的类可以协同工作。

适配器模式的主要作用是在“具有不同接口的类”之间进行协调，并为它们提供一个统一的接口。它是确保不同接口之间的兼容性的一种常用方式。

适配器模式的分类：

  1. 类适配器模式：通过继承来实现适配器。
  2. 对象适配器模式：通过组合来实现适配器。

2. 适配器模式的结构

适配器模式通常包含以下几个角色：

  1. 目标接口（Target Interface）： 定义客户所需的接口，它可以是抽象类或接口。

  2. 源类（Adaptee）：现有的类，其接口不符合目标接口的要求。

  3. 适配器（Adapter）：通过把独立的接口转换为客户所期望的接口，使得客户能够与源类进行交互。

img

3. 适配器模式的原理

适配器模式的原理是通过对现有接口的包装，转换成新的接口来实现兼容性。这样，现有的类不需要直接修改其实现，就可以满足客户端的需求。

在 Java 中，适配器模式可以分为类适配器和对象适配器实现：

  1. 类适配器：通过继承源类，并实现目标接口。
  2. 对象适配器：持有源类的引用，并通过组合来实现目标接口。

以下部分将通过 Java 示例来详细说明这两种实现方式。

4. 示例演示

4.1 类适配器实现示例

假设我们有一个界面，它需要一个 Bird 接口，而现有的 Sparrow 类实现了 Bird 接口，我们将需要一个适配器来适配另外一个 Duck 类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 目标接口
interface Bird {
    void chirp();
}

// 源类
class Sparrow implements Bird {
    @Override
    public void chirp() {
        System.out.println("Sparrow chirps!");
    }
}

// 需要适配的 Duck 类
class Duck {
    public void quack() {
        System.out.println("Duck quacks!");
    }
}

// 适配器类
class DuckAdapter extends Duck implements Bird {
    @Override
    public void chirp() {
        quack(); // 通过调用 Duck 的方法实现适配
    }
}

// 客户端代码
public class AdapterPatternTest {
    public static void main(String[] args) {
        Bird sparrow = new Sparrow();
        sparrow.chirp();

        Bird duckAdapter = new DuckAdapter();
        duckAdapter.chirp();
    }
}

在这个示例中，DuckAdapter 继承了 Duck 类，并实现了 Bird 接口。通过 DuckAdapter，我们可以将 Duck 对象转换为 Bird 对象，从而使得客户端可以以统一的方式与不同类型的鸟类互动。

4.2 对象适配器实现示例

同样的场景，我们可以使用对象适配器的形式来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 目标接口
interface Bird {
    void chirp();
}

// 源类
class Sparrow implements Bird {
    @Override
    public void chirp() {
        System.out.println("Sparrow chirps!");
    }
}

// 需要适配的 Duck 类
class Duck {
    public void quack() {
        System.out.println("Duck quacks!");
    }
}

// 适配器类
class DuckAdapter implements Bird {
    private Duck duck; // 持有 Duck 的引用

    public DuckAdapter(Duck duck) {
        this.duck = duck;
    }

    @Override
    public void chirp() {
        duck.quack(); // 调用 Duck 的 quack 方法
    }
}

// 客户端代码
public class AdapterPatternTest {
    public static void main(String[] args) {
        Bird sparrow = new Sparrow();
        sparrow.chirp();

        Duck duck = new Duck();
        Bird duckAdapter = new DuckAdapter(duck);
        duckAdapter.chirp();
    }
}

在这个示例中，DuckAdapter 持有一个 Duck 实例，并在 chirp 方法中调用 Duck 的 quack 方法。

5. 适配器模式的优缺点

5.1 优点

  1. 提高了代码的灵活性和可复用性：

    • 适配器模式允许新类的引入而不需要更改现有代码，使扩展变得更加简单。

  2. 可以实现接口之间的兼容：

    • 通过适配器，可以使不兼容的接口配合工作，从而使得不同系统之间的交互变得可能。

  3. 实现了接口的松耦合：

    • 客户代码无需知道被适配的类的具体类型，可以通过统一的接口进行调用，提高了代码的可维护性。

5.2 缺点

  1. 增加了复杂性：

    • 引入适配器后，系统的复杂性可能会增加，因为需要引入额外的适配器类。

  2. 性能开销：

    • 适配器模式在某些情况下可能会引入额外的开销，尤其是在频繁调用适配器方法的场景下。

  3. 可能会导致过度设计：

    • 在简单的场景下，如果为了使用适配器而引入过多的类，可能会造成过度设计和实现的复杂性。

6.适配器模式的应用场景

适配器模式通常适用于以下场景：

  1. 需要使用一些现有的类，而这些类的接口不符合您的需求。
  2. 希望通过一些类的封装或继承提供某种接口的转化。
  3. 当您希望使用一些库或框架，而它们的接口与您的应用程序不兼容时。

7. 总结

适配器模式是一种强大的设计模式，它通过将现有的类接口转化为适合客户需求的接口，提高了代码的灵活性和可复用性。虽然它可能会增加系统的复杂性，但在很多情况下，它提供了一种实现兼容性和通用性的有效方案。

在实际的开发中，理解适配器模式的使用场景及适当的实施方式，将极大地提高系统的可维护性和扩展性。

通过上述讲解，适配器模式的基本概念、结构及示例都已清晰呈现。在遇到接口不兼容的情况时，可以考虑使用适配器模式来解决问题。如果您还有其他问题或想法，欢迎继续探讨。

8. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing