【设计模式】【结构型模式(Structural Patterns)】之适配器模式(Adapter Pattern)

发布于:2024-11-29 ⋅ 阅读:(24) ⋅ 点赞:(0)

1. 设计模式原理说明

适配器模式(Adapter Pattern) 是一种结构型设计模式,它允许不兼容的接口协同工作。适配器模式可以将一个类的接口转换成另一个接口,使得原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式分为两种主要类型:类适配器和对象适配器。

主要角色
  1. Target(目标接口):这是客户端所期望的接口,客户端通过这个接口与适配器进行交互。
  2. Adaptee(适配者):这是需要适配的类,它具有不同的接口,但提供了我们需要的功能。
  3. Adapter(适配器):它是一个适配者类和目标接口之间的适配器,它实现了目标接口,并持有对适配者的引用,通过委托调用适配者的方法。

2. UML 类图及解释

UML 类图
+----------------+                +---------------------+
|     Target     |                |      Adaptee        |
|----------------|                |---------------------|
| + request(): void              | + specificRequest(): void|
+----------------+                +---------------------+
                                           
+----------------+                         |
|     Adapter    |                         |
|----------------|                         |
| - adaptee: Adaptee                       |
| + request(): void                        |
+----------------+                         |
                                           
+----------------+                         |
|     Client     |                         |
|----------------|                         |
| + mainMethod(): void                     |
+----------------+                         |
类图解释
  • Target:定义了客户端所期望的接口。客户端通过这个接口与适配器进行交互。
  • Adaptee:这是需要适配的类,它具有不同的接口,但提供了我们需要的功能。
  • Adapter:实现了 Target 接口,并持有对 Adaptee 的引用。适配器通过委托调用 Adaptee 的方法来实现 Target 接口的方法。
  • Client:客户端通过 Target 接口与适配器进行交互,从而间接使用 Adaptee 的功能。

3. 代码案例及逻辑详解

Java 代码案例
// 目标接口
interface Target {
    void request();
}

// 需要适配的类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specificRequest method is called.");
    }
}

// 适配器类
class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端
class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);

        adapter.request(); // 调用适配器的 request 方法
    }
}
C++ 代码案例
#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() = 0;
    virtual ~Target() {}
};

// 需要适配的类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee's specificRequest method is called." << std::endl;
    }
};

// 适配器类
class Adapter : public Target {
private:
    Adaptee* adaptee;

public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    ~Adapter() {
        delete adaptee;
    }

    void request() override {
        adaptee->specificRequest();
    }
};

// 客户端
int main() {
    Adaptee* adaptee = new Adaptee();
    Target* adapter = new Adapter(adaptee);

    adapter->request(); // 调用适配器的 request 方法

    delete adapter;
    return 0;
}
Python 代码案例
# 目标接口
class Target:
    def request(self):
        pass

# 需要适配的类
class Adaptee:
    def specific_request(self):
        print("Adaptee's specific_request method is called.")

# 适配器类
class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        self.adaptee.specific_request()

# 客户端
if __name__ == "__main__":
    adaptee = Adaptee()
    adapter = Adapter(adaptee)

    adapter.request()  # 调用适配器的 request 方法
Go 代码案例
package main

import "fmt"

// 目标接口
type Target interface {
    Request()
}

// 需要适配的类
type Adaptee struct{}

func (a *Adaptee) SpecificRequest() {
    fmt.Println("Adaptee's specificRequest method is called.")
}

// 适配器类
type Adapter struct {
    adaptee *Adaptee
}

func (a *Adapter) Request() {
    a.adaptee.SpecificRequest()
}

// 客户端
func main() {
    adaptee := &Adaptee{}
    adapter := &Adapter{adaptee: adaptee}

    adapter.Request() // 调用适配器的 Request 方法
}

4. 总结

适配器模式 是一种结构型设计模式,它允许不兼容的接口协同工作。适配器模式通过创建一个适配器类来实现目标接口,并持有对适配者类的引用,从而将适配者的方法转换为目标接口的方法。

主要优点
  1. 提高了类的复用性:通过适配器模式,可以重用现有的类,而不需要修改它们的源代码。
  2. 增加了灵活性:适配器模式使得系统更易于扩展,因为可以在不修改原有代码的情况下引入新的适配器。
  3. 分离接口和实现:适配器模式将接口和实现分离,使得系统的职责更加清晰。
主要缺点
  1. 增加了系统的复杂性:适配器模式会增加系统的类的数量,从而使系统更加复杂。
  2. 过度设计的风险:如果在没有必要的情况下使用适配器模式,可能会导致过度设计。

总的来说,适配器模式适用于以下场景:

  • 当希望使用一个已经存在的类,但其接口不符合需求时。
  • 当希望创建一个可以复用的类,该类可以与其他不兼容的类或接口一起工作时。
  • 当需要在系统中动态地添加或删除某些功能时,适配器模式可以提供一种灵活的解决方案。

网站公告

今日签到

点亮在社区的每一天
去签到