• 设计模式：桥接模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《适配器模式》                                                                 下一篇《装饰器模式》

    简介：

    桥接模式，它是一种结构型设计模式，它的主要目的是将抽象部分与具体实现部分分离，使它们都可以独立地变化。桥接模式通过使用封装、聚合及继承等行为让不同的类承担不同的职责，从而把抽象（Abstraction）与行为实现（Implementation）分离开来，以保持各部分的独立性以及应对他们的功能扩展。

    桥接模式的结构包括以下主要角色：
    1、抽象类（AbstractClass）：定义了抽象接口，并实现了部分功能。
    2、具体实现类（ConcreteClass）：实现了抽象类所定义的具体接口，完成抽象类的功能实现。
    3、桥接类（BridgeClass）：将抽象类和具体实现类连接起来，使得它们可以独立地变化。

    桥接模式的使用场景：
    1、系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系。此时，可以通过桥接模式使他们在抽象层建立一个关联关系。
    2、系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
    3、一个类存在两个独立变化的维度，而这两个维度都需要进行扩展。

    桥接模式的创建步骤：
    1、创建抽象类（AbstractClass），它定义了抽象接口，并实现了部分功能。
    2、创建具体实现类（ConcreteClass），它实现了抽象类所定义的具体接口，完成抽象类的功能实现。
    3、创建桥接类（BridgeClass），它将抽象类和具体实现类连接起来，使得它们可以独立地变化。

    桥接模式的优点，主要包括：
    1、分离抽象及其实现部分：桥接模式通过将抽象部分与实现部分分离，使得它们可以独立地变化。这种分离有助于降低对实现部分编译时刻的依赖性，当改变一个实现类时，并需要重新编译抽象类和它的客户程序。同时，接口与实现分离有助于分层，从而产生更好的结构化系统，系统的高层部分仅需知道抽象类和具体实现类即可。
    2、提高可扩充性：桥接模式使得抽象类和具体实现类可以独立地变化，因此可以独立地对它们进行扩展。这种扩展能力有助于提高系统的可维护性和可重用性。
    3、优秀的扩展能力：桥接模式使得抽象类和具体实现类可以独立地变化，因此可以灵活地添加新的具体实现类，以满足新的需求。这种扩展能力使得系统能够适应未来的变化和发展。

    总之，桥接模式通过将抽象部分与实现部分分离，提高了系统的可维护性、可重用性和可扩展性，同时降低了系统的复杂性。

    桥接模式的缺点，主要包括：
    1、增加了系统的理解和设计难度。由于关联关系建立在抽象层，要求开发者一开始就针对抽象层进行设计与编程，正确识别出系统中两个独立变化的维度并不容易。
    2、可能增加系统的复杂性。对于一些不希望使用继承或因为多层继承导致系统类的个数剧增的场景，可能需要考虑使用桥接模式，这会增加系统的复杂性和理解难度。

    总之，桥接模式虽然可以提高系统的可维护性、可重用性和可扩展性，但也增加了系统的复杂性和理解难度。因此，在使用桥接模式时需要权衡其优缺点，根据实际需求进行选择。

    示例：

    一、C#桥接模式

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

    1. using System;  
    2.   
    3. namespace BridgePatternExample  
    4. {  
    5.     // 抽象类  
    6.     public abstract class Abstraction  
    7.     {  
    8.         protected Implementor implementor;  
    9.       
    10.         public void SetImplementor(Implementor implementor)  
    11.         {  
    12.             this.implementor = implementor;  
    13.         }  
    14.       
    15.         public abstract void Operation();  
    16.     }  
    17.       
    18.     // 具体实现类  
    19.     public class ConcreteAbstraction : Abstraction  
    20.     {  
    21.         public override void Operation()  
    22.         {  
    23.             implementor.Operation();  
    24.         }  
    25.     }  
    26.   
    27.     // 实现接口  
    28.     public interface Implementor  
    29.     {  
    30.         void Operation();  
    31.     }  
    32.       
    33.     // 具体实现类1  
    34.     public class ConcreteImplementor1 : Implementor  
    35.     {  
    36.         public void Operation()  
    37.         {  
    38.             Console.WriteLine("Concrete Implementor 1 operation");  
    39.         }  
    40.     }  
    41.       
    42.     // 具体实现类2  
    43.     public class ConcreteImplementor2 : Implementor  
    44.     {  
    45.         public void Operation()  
    46.         {  
    47.             Console.WriteLine("Concrete Implementor 2 operation");  
    48.         }  
    49.     }
    50.   
    51.     class Program  
    52.     {  
    53.         static void Main(string[] args)  
    54.         {  
    55.             Abstraction abstraction = new ConcreteAbstraction();  
    56.             abstraction.SetImplementor(new ConcreteImplementor1()); // 第一个实现类操作  
    57.             abstraction.Operation(); // 输出 "Concrete Implementor 1 operation"  
    58.             abstraction.SetImplementor(new ConcreteImplementor2()); // 第二个实现类操作  
    59.             abstraction.Operation(); // 输出 "Concrete Implementor 2 operation"  
    60.         }   
    61.     }   
    62. }

    二、java桥接模式

    桥接模式通常通过以下方式实现：

    1. // 抽象类  
    2. public abstract class AbstractClass {  
    3.     protected Implementor implementor;  
    4.     
    5.     public void setImplementor(Implementor implementor) {  
    6.         this.implementor = implementor;  
    7.     }  
    8.     
    9.     public abstract void operation();  
    10. }  
    11.    
    12. // 具体实现类  
    13. public class ConcreteClass extends AbstractClass {  
    14.     @Override  
    15.     public void operation() {  
    16.         implementor.operation();  
    17.     }  
    18. }  
    19.    
    20. // 实现接口  
    21. public interface Implementor {  
    22.     void operation();  
    23. }  
    24.    
    25. // 具体实现类1  
    26. public class ConcreteImplementor1 implements Implementor {  
    27.     @Override  
    28.     public void operation() {  
    29.         System.out.println("Concrete Implementor 1 operation");  
    30.     }  
    31. }  
    32.    
    33. // 具体实现类2  
    34. public class ConcreteImplementor2 implements Implementor {  
    35.     @Override  
    36.     public void operation() {  
    37.         System.out.println("Concrete Implementor 2 operation");  
    38.     }  
    39. }
    40.  
    41. //在客户端中创建上下文对象并注入具体策略对象
    42. public class Main {  
    43.     public static void main(String[] args) {  
    44.         AbstractClass abstraction = new ConcreteClass();  
    45.         abstraction.setImplementor(new ConcreteImplementor1()); // 第一个实现类操作  
    46.         abstraction.operation(); // 输出 "Concrete Implementor 1 operation"  
    47.         abstraction.setImplementor(new ConcreteImplementor2()); // 第二个实现类操作  
    48.         abstraction.operation(); // 输出 "Concrete Implementor 2 operation"
    49.     }
    50. }

    三、javascript桥接模式

    在JavaScript中，桥接实现方式如下：

    1. // 抽象类  
    2. class AbstractClass {  
    3.   constructor(bridge) {  
    4.     this.bridge = bridge;  
    5.   }  
    6.   
    7.   operation() {  
    8.     this.bridge.implementationOperation();  
    9.   }  
    10. }  
    11.   
    12. // 具体实现类  
    13. class ConcreteClass1 {  
    14.   implementationOperation() {  
    15.     console.log('ConcreteClass1 operation');  
    16.   }  
    17. }  
    18.   
    19. class ConcreteClass2 {  
    20.   implementationOperation() {  
    21.     console.log('ConcreteClass2 operation');  
    22.   }  
    23. }  
    24.   
    25. // 桥接类  
    26. class BridgeClass extends AbstractClass {  
    27.   constructor(implementation) {  
    28.     super(implementation);  
    29.   }  
    30. }
    31.  
    32. const bridge1 = new BridgeClass(new ConcreteClass1());  
    33. const bridge2 = new BridgeClass(new ConcreteClass2());  
    34.     
    35. bridge1.operation(); // 输出 "ConcreteClass1 operation"  
    36. bridge2.operation(); // 输出 "ConcreteClass2 operation"

    四、C++桥接模式

    以下是在C++中实现桥接模式：

    1. #include   
    2.   
    3. // 抽象类  
    4. class AbstractClass {  
    5. public:  
    6.     virtual void operation() = 0;  
    7. };  
    8.   
    9. // 具体实现类1  
    10. class ConcreteClass1 : public AbstractClass {  
    11. public:  
    12.     void operation() override {  
    13.         std::cout << "ConcreteClass1 operation" << std::endl;  
    14.     }  
    15. };  
    16.   
    17. // 具体实现类2  
    18. class ConcreteClass2 : public AbstractClass {  
    19. public:  
    20.     void operation() override {  
    21.         std::cout << "ConcreteClass2 operation" << std::endl;  
    22.     }  
    23. };  
    24.   
    25. // 桥接类  
    26. class BridgeClass {  
    27. public:  
    28.     AbstractClass* abstract;  
    29.     BridgeClass(AbstractClass* a) : abstract(a) {}  
    30.     void operation() { abstract->operation(); }  
    31. };  
    32.   
    33. int main() {  
    34.     AbstractClass* a = new ConcreteClass1(); // 使用具体实现类1创建抽象类的对象  
    35.     BridgeClass b(a); // 使用桥接类与抽象类的对象进行交互  
    36.     b.operation(); // 输出 "ConcreteClass1 operation"  
    37.     delete a; // 释放内存  
    38.     a = new ConcreteClass2(); // 使用具体实现类2创建抽象类的对象  
    39.     b.operation(); // 输出 "ConcreteClass2 operation"  
    40.     delete a; // 释放内存  
    41.     return 0;  
    42. }

    五、python桥接模式

    以下是在python中实现桥接模式：

    1. from abc import ABC, abstractmethod  
    2.   
    3. # 抽象类  
    4. class AbstractClass(ABC):  
    5.     @abstractmethod  
    6.     def operation(self):  
    7.         pass  
    8.   
    9. # 具体实现类1  
    10. class ConcreteClass1(AbstractClass):  
    11.     def operation(self):  
    12.         print("ConcreteClass1 operation")  
    13.   
    14. # 具体实现类2  
    15. class ConcreteClass2(AbstractClass):  
    16.     def operation(self):  
    17.         print("ConcreteClass2 operation")  
    18.   
    19. # 桥接类  
    20. class BridgeClass:  
    21.     def __init__(self, abstract_class):  
    22.         self.abstract_class = abstract_class  
    23.       
    24.     def operation(self):  
    25.         self.abstract_class.operation()  
    26.   
    27. # 使用示例：  
    28. bridge1 = BridgeClass(ConcreteClass1())  
    29. bridge2 = BridgeClass(ConcreteClass2())  
    30. bridge1.operation() # 输出 "ConcreteClass1 operation"  
    31. bridge2.operation() # 输出 "ConcreteClass2 operation"

    六、go桥接模式

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

    1. package main  
    2.   
    3. import "fmt"  
    4.   
    5. // 抽象类  
    6. type AbstractClass struct {  
    7.     BridgeClass  
    8. }  
    9.   
    10. func (ac *AbstractClass) Operation() {  
    11.     ac.BridgeClass.Operation()  
    12. }  
    13.   
    14. // 具体实现类1  
    15. type ConcreteClass1 struct{}  
    16.   
    17. func (cc1 *ConcreteClass1) Operation() {  
    18.     fmt.Println("ConcreteClass1 operation")  
    19. }  
    20.   
    21. // 具体实现类2  
    22. type ConcreteClass2 struct{}  
    23.   
    24. func (cc2 *ConcreteClass2) Operation() {  
    25.     fmt.Println("ConcreteClass2 operation")  
    26. }  
    27.   
    28. // 桥接类  
    29. type BridgeClass struct {  
    30.     impl interface{}  
    31. }  
    32.   
    33. func (bc *BridgeClass) Operation() {  
    34.     bc.impl.Operation()  
    35. }  
    36.   
    37. func main() {  
    38.     abstract := &AbstractClass{&BridgeClass{&ConcreteClass1{}}}  
    39.     abstract.Operation() // 输出 "ConcreteClass1 operation"  
    40.   
    41.     abstract.BridgeClass.impl = &ConcreteClass2{}  
    42.     abstract.Operation() // 输出 "ConcreteClass2 operation"  
    43. }

    七、PHP桥接模式

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

    1.   
    2.   
    3. // 抽象类  
    4. abstract class AbstractClass {  
    5.     protected $bridge;  
    6.       
    7.     public function __construct(BridgeClass $bridge) {  
    8.         $this->bridge = $bridge;  
    9.     }  
    10.       
    11.     abstract public function operation();  
    12. }  
    13.   
    14. // 具体实现类1  
    15. class ConcreteClass1 implements AbstractClass {  
    16.     public function operation() {  
    17.         echo "ConcreteClass1 operation\n";  
    18.     }  
    19. }  
    20.   
    21. // 具体实现类2  
    22. class ConcreteClass2 implements AbstractClass {  
    23.     public function operation() {  
    24.         echo "ConcreteClass2 operation\n";  
    25.     }  
    26. }  
    27.   
    28. // 桥接类  
    29. class BridgeClass {  
    30.     protected $implementation;  
    31.       
    32.     public function __construct(Implementation $implementation) {  
    33.         $this->implementation = $implementation;  
    34.     }  
    35.       
    36.     public function operation() {  
    37.         $this->implementation->operation();  
    38.     }  
    39. }  
    40.   
    41. // 使用示例：  
    42. $bridge1 = new BridgeClass(new ConcreteClass1());  
    43. $bridge2 = new BridgeClass(new ConcreteClass2());  
    44. $bridge1->operation(); // 输出 "ConcreteClass1 operation"  
    45. $bridge2->operation(); // 输出 "ConcreteClass2 operation"


    《完结》

    上一篇《适配器模式》                                                               下一篇《装饰器模式》          

  • 相关阅读:
    GBase 8c V3.0.0数据类型——访问权限查询函数
    京东商品详情API，页面信息采集，优惠券信息获取
    利用pymupdf编辑修改pdf
    （持续更新中！）详解【计算机类&面试真题】军队文职考试 ——第二期（真题+解析）| 网络协议的三个核心要素；交互式系统中的非剥夺策略；中断和陷入的区别；可变分区管理中的硬件机制；数据库系统的优点
    centos7 mysql5.7离线安装
    Akka框架：Scala并发编程的瑞士军刀
    单位建数字档案室的意义和作用
    爬虫都可以干什么？
    C++字节对齐
    window.eventBus 在Vue中的使用方法（一）
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/134001037