• 设计模式：适配器模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《建造者模式》                                                                 下一篇《桥接模式》

    简介：

    适配器模式，它是一种结构型设计模式，它用于将一个类的接口转换成客户端所期待的另一种接口，使得原本因接口不兼容而无法一起工作的两个类能够协同工作。
    适配器模式包括类适配器模式和对象适配器模式。类适配器模式依赖于继承关系实现，因此其耦合度较高。对象适配器模式则依赖于组合或聚合关系实现，因此其耦合度较低。
    适配器模式的结构包括抽象原有接口、具体原有接口、抽象目标接口和适配器。适配器实现抽象目标接口，并实现目标接口的行为。
    适配器模式包含以下三个角色：
    1、源（Adaptee）：需要被适配的对象或类型，相当于插头。
    2、适配器（Adapter）：连接目标和源的中间对象，相当于插头转换器。
    3、目标（Target）：期待得到的目标，相当于插座。

    适配器模式的使用场景：
    1、系统需要使用现有的类，但现有类的接口不符合系统的需要。
    2、需要一个统一的输出接口，而输入类型不可预知。例如，在Android开发中的Adapter模式，用户的数据各式各样，但最终都是通过getView()返回一个View，这是适配器模式的一个很好的应用场景。
    3、创建一个可以复用的类。例如，Android中的Adapter模式可以使得该类可以与其他不相关的类或不可预见的类协同工作。

    适配器模式是一种结构型设计模式，它用于将一个类的接口转换成客户端所期待的另一种接口，使得原本因接口不兼容而无法一起工作的两个类能够协同工作。

    适配器模式的创建步骤：
    1、创建Target接口。这个接口定义了目标类需要实现的方法。
    2、创建源类(Adaptee)。这个类中可能包含了一些需要适配的方法。
    3、创建适配器类(Adapter)。该类继承自源类并实现目标接口。适配器类需要实现目标接口中定义的方法，并将源类的原有方法封装成符合目标接口要求的方法。

    在适配器类中，我们需要将Target接口的方法和Adaptee类的方法进行适配。具体来说，我们需要将Target接口的方法调用转发到Adaptee类的方法上。

    适配器模式的优点，主要包括：
    1、更好的复用性：适配器模式允许系统使用已经存在的类，即使其接口不符合系统的需求，通过适配器模式可以解决不兼容的问题，使这些功能类得到复用。
    2、增加类的透明性和复用性：适配器模式将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。
    3、灵活性和扩展性：适配器模式通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

    适配器模式的缺点，主要包括：
    1、增加系统的复杂性：适配器模式需要引入一个额外的适配器类，增加了系统的复杂性。
    不适合大型系统：适配器模式会导致系统的结构变得复杂，并可能影响到系统的性能，因此不适合大型系统。
    2、破坏封装性：适配器模式需要访问适配者的私有方法和属性，这会破坏适配者的封装性。
    3、降低了代码的可读性和可维护性：由于适配器模式的使用需要额外的类和方法，这会使得代码更加复杂和难以理解，降低了代码的可读性和可维护性。

    示例：

    一、C#适配器模式

    以下是一个示例，展示了如何在C#中实现适配器模式：

    1. using System;  
    2.   
    3. // 目标接口  
    4. public interface Target  
    5. {  
    6.     void Request();  
    7. }  
    8.   
    9. // 源类  
    10. public class Adaptee
    11. {  
    12.     public void SpecificRequest()  
    13.     {  
    14.         Console.WriteLine("Adaptee's specific request.");  
    15.     }  
    16. }  
    17.   
    18. // 适配器类  
    19. public class Adapter : Target  
    20. {  
    21.     private Adaptee adaptee;  
    22.   
    23.     public Adapter(Adaptee adaptee)  
    24.     {  
    25.         this.adaptee = adaptee;  
    26.     }  
    27.   
    28.     public void Request()  
    29.     {  
    30.         adaptee.SpecificRequest();  
    31.     }  
    32. }  
    33.   
    34. // 客户端类  
    35. public class Client  
    36. {  
    37.     public static void Main()  
    38.     {  
    39.         Adaptee adaptee = new Adaptee(); // 创建源类对象  
    40.         Target target = new Adapter(adaptee); // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    41.         target.Request(); // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    42.     }  
    43. }

    二、java适配器模式

    适配器模式通常通过以下方式实现：

    1. // 目标接口  
    2. interface Target {  
    3.     void request();  
    4. }  
    5.   
    6. // 源类  
    7. class Adaptee {  
    8.     public void specificRequest() {  
    9.         System.out.println("Adaptee's specific request.");  
    10.     }  
    11. }  
    12.   
    13. // 适配器类  
    14. class Adapter implements Target {  
    15.     private Adaptee adaptee;  
    16.   
    17.     public Adapter(Adaptee adaptee) {  
    18.         this.adaptee = adaptee;  
    19.     }  
    20.   
    21.     public void request() {  
    22.         adaptee.specificRequest();  
    23.     }  
    24. }  
    25.   
    26. // 客户端类  
    27. class Client {  
    28.     public static void main(String[] args) {  
    29.         Adaptee adaptee = new Adaptee(); // 创建源类对象  
    30.         Target target = new Adapter(adaptee); // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    31.         target.request(); // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    32.     }  
    33. }

    三、javascript适配器模式

    在JavaScript中，适配器实现方式如下：

    1. // 目标接口  
    2. interface Target {  
    3.   request();  
    4. }  
    5.   
    6. // 源类  
    7. class Adaptee {  
    8.   specificRequest() {  
    9.     console.log('Adaptee\'s specific request.');  
    10.   }  
    11. }  
    12.   
    13. // 适配器类  
    14. class Adapter implements Target {  
    15.   constructor(adaptee: Adaptee) {  
    16.     this.adaptee = adaptee;  
    17.   }  
    18.   
    19.   request() {  
    20.     this.adaptee.specificRequest();  
    21.   }  
    22. }  
    23.   
    24. // 客户端类  
    25. class Client {  
    26.   static main() {  
    27.     const adaptee = new Adaptee(); // 创建源类对象  
    28.     const target = new Adapter(adaptee); // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    29.     target.request(); // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    30.   }  
    31. }

    四、C++适配器模式

    以下是在C++中实现适配器模式：

    1. // 目标接口  
    2. class Target {  
    3. public:  
    4.     virtual void request() = 0;  
    5. };  
    6.   
    7. // 源类  
    8. class Adaptee {  
    9. public:  
    10.     void specificRequest() {  
    11.         cout << "Adaptee's specific request." << endl;  
    12.     }  
    13. };  
    14.   
    15. // 适配器类  
    16. class Adapter : public Adaptee, public Target {  
    17. public:  
    18.     void request() override {  
    19.         specificRequest();  
    20.     }  
    21. };  
    22.   
    23. // 客户端类  
    24. class Client {  
    25. public:  
    26.     static void main() {  
    27.         Adaptee* adaptee = new Adaptee(); // 创建源类对象  
    28.         Target* target = new Adapter(adaptee); // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    29.         target->request(); // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    30.     }  
    31. };

    五、python适配器模式

    下面是一个简单的Python适配器模式示例：

    1. # 目标接口  
    2. class Target:  
    3.     def request(self):  
    4.         pass  
    5.   
    6. # 源类  
    7. class Adaptee:  
    8.     def specific_request(self):  
    9.         print("Adaptee's specific request.")  
    10.   
    11. # 适配器类  
    12. class Adapter(Adaptee, Target):  
    13.     def request(self):  
    14.         self.specific_request()  
    15.   
    16. # 客户端类  
    17. class Client:  
    18.     def main(self):  
    19.         adaptee = Adaptee() # 创建源类对象  
    20.         target = Adapter(adaptee) # 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    21.         target.request() # 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    22.   
    23. client = Client()  
    24. client.main()

    六、go适配器模式

    以下是一个示例，展示了如何在go中实现适配器模式：

    1. package main  
    2.   
    3. import "fmt"  
    4.   
    5. // 目标接口  
    6. type Target interface {  
    7.  Request()  
    8. }  
    9.   
    10. // 源类  
    11. type Adaptee struct{}  
    12.   
    13. func (a *Adaptee) SpecificRequest() {  
    14.  fmt.Println("Adaptee's specific request.")  
    15. }  
    16.   
    17. // 适配器类  
    18. type Adapter struct {  
    19.  adaptee *Adaptee  
    20. }  
    21.   
    22. func (a *Adapter) Request() {  
    23.  a.adaptee.SpecificRequest()  
    24. }  
    25.   
    26. // 客户端类  
    27. type Client struct{}  
    28.   
    29. func (c *Client) Main() {  
    30.  adaptee := &Adaptee{} // 创建源类对象  
    31.  target := &Adapter{adaptee: adaptee} // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    32.  target.Request() // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    33. }  
    34.   
    35. func main() {  
    36.  client := &Client{} // 创建客户端对象  
    37.  client.Main() // 执行客户端的主要逻辑，完成适配器的使用示例  
    38. }

    七、PHP适配器模式

    以下是一个示例，展示了如何在PHP中实现适配器模式：

    1. interface Target {  
    2.     public function request();  
    3. }  
    4.   
    5. class Adaptee {  
    6.     public function specificRequest() {  
    7.         echo "Adaptee's specific request.";  
    8.     }  
    9. }  
    10.   
    11. class Adapter implements Target {  
    12.     private $adaptee;  
    13.   
    14.     public function __construct(Adaptee $adaptee) {  
    15.         $this->adaptee = $adaptee;  
    16.     }  
    17.   
    18.     public function request() {  
    19.         $this->adaptee->specificRequest();  
    20.     }  
    21. }  
    22.   
    23. class Client {  
    24.     public function main() {  
    25.         $adaptee = new Adaptee(); // 创建源类对象  
    26.         $target = new Adapter($adaptee); // 创建适配器，并将源类对象传入适配器构造函数中进行适配  
    27.         $target->request(); // 客户端调用目标接口中的方法，实际上会调用适配器中的方法，适配器中会调用源类的方法  
    28.     }  
    29. }  
    30.   
    31. $client = new Client();  
    32. $client->main();

    在上面的示例中，目标接口是Target，它定义了客户端所期待的接口。源类是Adaptee，它拥有原本的接口，但不符合目标接口。适配器类是Adapter，它实现目标接口并封装源类的原有方法。客户端类是Client，它通过调用目标接口中定义的方法来调用适配器类的方法。适配器的内部会自动调用源类的方法，实现了源类和目标接口的适配。

    《完结》

    上一篇《建造者模式》                                                                     下一篇《桥接模式》

  • 相关阅读:
    什么是物联网？定义和解释
    react: antd组件使用 FC Fragment
    [MRCTF2020]套娃 php字符串解析绕过，jsfuck编码
    按周的日期下拉组件
    基于卷积神经网络实现手写数字识别
    打造高性能应用，持续优化用户体验
    Nginx：尚硅谷2022版Nginx笔记
    深度学习 常见的损失函数
    【Android】带下划线的TextView
    react_14
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133979678