当前位置： 首页 > article >正文

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

article 2024/11/15 4:14:26

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

简介：

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

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

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

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

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

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

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

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

示例：

一、C#桥接模式

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

using System;  
  
namespace BridgePatternExample  
{  
    // 抽象类  
    public abstract class Abstraction  
    {  
        protected Implementor implementor;  
      
        public void SetImplementor(Implementor implementor)  
        {  
            this.implementor = implementor;  
        }  
      
        public abstract void Operation();  
    }  
      
    // 具体实现类  
    public class ConcreteAbstraction : Abstraction  
    {  
        public override void Operation()  
        {  
            implementor.Operation();  
        }  
    }  
  
    // 实现接口  
    public interface Implementor  
    {  
        void Operation();  
    }  
      
    // 具体实现类1  
    public class ConcreteImplementor1 : Implementor  
    {  
        public void Operation()  
        {  
            Console.WriteLine("Concrete Implementor 1 operation");  
        }  
    }  
      
    // 具体实现类2  
    public class ConcreteImplementor2 : Implementor  
    {  
        public void Operation()  
        {  
            Console.WriteLine("Concrete Implementor 2 operation");  
        }  
    }
  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Abstraction abstraction = new ConcreteAbstraction();  
            abstraction.SetImplementor(new ConcreteImplementor1()); // 第一个实现类操作  
            abstraction.Operation(); // 输出 "Concrete Implementor 1 operation"  
            abstraction.SetImplementor(new ConcreteImplementor2()); // 第二个实现类操作  
            abstraction.Operation(); // 输出 "Concrete Implementor 2 operation"  
        }   
    }   
}

二、java桥接模式

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

// 抽象类  
public abstract class AbstractClass {  
    protected Implementor implementor;  
    
    public void setImplementor(Implementor implementor) {  
        this.implementor = implementor;  
    }  
    
    public abstract void operation();  
}  
   
// 具体实现类  
public class ConcreteClass extends AbstractClass {  
    @Override  
    public void operation() {  
        implementor.operation();  
    }  
}  
   
// 实现接口  
public interface Implementor {  
    void operation();  
}  
   
// 具体实现类1  
public class ConcreteImplementor1 implements Implementor {  
    @Override  
    public void operation() {  
        System.out.println("Concrete Implementor 1 operation");  
    }  
}  
   
// 具体实现类2  
public class ConcreteImplementor2 implements Implementor {  
    @Override  
    public void operation() {  
        System.out.println("Concrete Implementor 2 operation");  
    }  
}

//在客户端中创建上下文对象并注入具体策略对象
public class Main {  
    public static void main(String[] args) {  
        AbstractClass abstraction = new ConcreteClass();  
        abstraction.setImplementor(new ConcreteImplementor1()); // 第一个实现类操作  
        abstraction.operation(); // 输出 "Concrete Implementor 1 operation"  
        abstraction.setImplementor(new ConcreteImplementor2()); // 第二个实现类操作  
        abstraction.operation(); // 输出 "Concrete Implementor 2 operation"
    }
}

三、javascript桥接模式

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

// 抽象类  
class AbstractClass {  
  constructor(bridge) {  
    this.bridge = bridge;  
  }  
  
  operation() {  
    this.bridge.implementationOperation();  
  }  
}  
  
// 具体实现类  
class ConcreteClass1 {  
  implementationOperation() {  
    console.log('ConcreteClass1 operation');  
  }  
}  
  
class ConcreteClass2 {  
  implementationOperation() {  
    console.log('ConcreteClass2 operation');  
  }  
}  
  
// 桥接类  
class BridgeClass extends AbstractClass {  
  constructor(implementation) {  
    super(implementation);  
  }  
}

const bridge1 = new BridgeClass(new ConcreteClass1());  
const bridge2 = new BridgeClass(new ConcreteClass2());  
    
bridge1.operation(); // 输出 "ConcreteClass1 operation"  
bridge2.operation(); // 输出 "ConcreteClass2 operation"

四、C++桥接模式

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

#include <iostream>  
  
// 抽象类  
class AbstractClass {  
public:  
    virtual void operation() = 0;  
};  
  
// 具体实现类1  
class ConcreteClass1 : public AbstractClass {  
public:  
    void operation() override {  
        std::cout << "ConcreteClass1 operation" << std::endl;  
    }  
};  
  
// 具体实现类2  
class ConcreteClass2 : public AbstractClass {  
public:  
    void operation() override {  
        std::cout << "ConcreteClass2 operation" << std::endl;  
    }  
};  
  
// 桥接类  
class BridgeClass {  
public:  
    AbstractClass* abstract;  
    BridgeClass(AbstractClass* a) : abstract(a) {}  
    void operation() { abstract->operation(); }  
};  
  
int main() {  
    AbstractClass* a = new ConcreteClass1(); // 使用具体实现类1创建抽象类的对象  
    BridgeClass b(a); // 使用桥接类与抽象类的对象进行交互  
    b.operation(); // 输出 "ConcreteClass1 operation"  
    delete a; // 释放内存  
    a = new ConcreteClass2(); // 使用具体实现类2创建抽象类的对象  
    b.operation(); // 输出 "ConcreteClass2 operation"  
    delete a; // 释放内存  
    return 0;  
}

五、python桥接模式

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

from abc import ABC, abstractmethod  
  
# 抽象类  
class AbstractClass(ABC):  
    @abstractmethod  
    def operation(self):  
        pass  
  
# 具体实现类1  
class ConcreteClass1(AbstractClass):  
    def operation(self):  
        print("ConcreteClass1 operation")  
  
# 具体实现类2  
class ConcreteClass2(AbstractClass):  
    def operation(self):  
        print("ConcreteClass2 operation")  
  
# 桥接类  
class BridgeClass:  
    def __init__(self, abstract_class):  
        self.abstract_class = abstract_class  
      
    def operation(self):  
        self.abstract_class.operation()  
  
# 使用示例：  
bridge1 = BridgeClass(ConcreteClass1())  
bridge2 = BridgeClass(ConcreteClass2())  
bridge1.operation() # 输出 "ConcreteClass1 operation"  
bridge2.operation() # 输出 "ConcreteClass2 operation"

六、go桥接模式

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

package main  
  
import "fmt"  
  
// 抽象类  
type AbstractClass struct {  
    BridgeClass  
}  
  
func (ac *AbstractClass) Operation() {  
    ac.BridgeClass.Operation()  
}  
  
// 具体实现类1  
type ConcreteClass1 struct{}  
  
func (cc1 *ConcreteClass1) Operation() {  
    fmt.Println("ConcreteClass1 operation")  
}  
  
// 具体实现类2  
type ConcreteClass2 struct{}  
  
func (cc2 *ConcreteClass2) Operation() {  
    fmt.Println("ConcreteClass2 operation")  
}  
  
// 桥接类  
type BridgeClass struct {  
    impl interface{}  
}  
  
func (bc *BridgeClass) Operation() {  
    bc.impl.Operation()  
}  
  
func main() {  
    abstract := &AbstractClass{&BridgeClass{&ConcreteClass1{}}}  
    abstract.Operation() // 输出 "ConcreteClass1 operation"  
  
    abstract.BridgeClass.impl = &ConcreteClass2{}  
    abstract.Operation() // 输出 "ConcreteClass2 operation"  
}

七、PHP桥接模式

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

<?php  
  
// 抽象类  
abstract class AbstractClass {  
    protected $bridge;  
      
    public function __construct(BridgeClass $bridge) {  
        $this->bridge = $bridge;  
    }  
      
    abstract public function operation();  
}  
  
// 具体实现类1  
class ConcreteClass1 implements AbstractClass {  
    public function operation() {  
        echo "ConcreteClass1 operation\n";  
    }  
}  
  
// 具体实现类2  
class ConcreteClass2 implements AbstractClass {  
    public function operation() {  
        echo "ConcreteClass2 operation\n";  
    }  
}  
  
// 桥接类  
class BridgeClass {  
    protected $implementation;  
      
    public function __construct(Implementation $implementation) {  
        $this->implementation = $implementation;  
    }  
      
    public function operation() {  
        $this->implementation->operation();  
    }  
}  
  
// 使用示例：  
$bridge1 = new BridgeClass(new ConcreteClass1());  
$bridge2 = new BridgeClass(new ConcreteClass2());  
$bridge1->operation(); // 输出 "ConcreteClass1 operation"  
$bridge2->operation(); // 输出 "ConcreteClass2 operation"


《完结》

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


http://www.kler.cn/a/108139.html

相关文章：

  • 基于标签相关性的多标签学习
  • [CKS] K8S NetworkPolicy Set Up
  • 【stable diffusion部署】超强AI绘画Stable Diffusion，本地部署使用教程，完全免费使用
  • 系统上线后发现bug，如何回退版本？已经产生的新业务数据怎么办？
  • AI 写作（五）核心技术之文本摘要：分类与应用（5/10）
  • 【深圳大学】数据结构A+攻略（计软版）
  • vue中父组件给子组件传递了参数后，什么时候确保子组件中收到的参数更新了
  • 创新领航 | 竹云参编《基于区块链的数据资产评估实施指南》正式发布！
  • 【Python机器学习】零基础掌握MissingIndicator缺失值填充
  • Node.js的基本概念node -v 和npm -v 这两个命令的作用
  • 华为数通方向HCIP-DataCom H12-831题库(多选题：101-120）
  • 2016年下半年上午易错题（软件设计师考试）
  • [100天算法】-连通网络的操作次数（day 46）
  • LVS-DR模式+keepalived+nginx+tomcat实现动静分离、负载均衡、高可用实验
  • 方舟生存进化ARK个人服务器搭建教程保姆级
  • 聊一下Word2vec-训练优化篇
  • 【Python爬虫三天从0到1】Day1：爬虫核心
  • 计算机视觉-光源的目的和作用
  • autoware.ai中检测模块lidar_detector caffe
  • vscode markdown 使用技巧 -- 如何快速打出一个Tab 或多个空格
  • Web3 治理实践探讨：如何寻找多元化发展路径？
  • 【python练习】在棋盘上收集奖品，跟着书本理思路
  • 2-Java进阶知识总结-6-多线程
  • shell脚本的编写（输入、输出、变量、数组等的使用规范及实例）
  • 【鸿蒙软件开发】ArkTS基础组件之TextClock(时间显示文本)、TextPicker(滑动选择文本)
  • 手写RPC框架