设计模式——9. 桥接模式

已于 2023-10-08 23:05:00 修改
阅读量209 收藏 1
点赞数 1
分类专栏： 设计模式大全 文章标签： 设计模式 桥接模式 java python golang c++ javascript
于 2023-10-03 11:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133500978
版权

1. 说明

桥接模式（Bridge Pattern）是一种结构型设计模式，它用于将抽象部分和具体实现部分分离，以便它们可以独立地变化而不互相影响。桥接模式通过将抽象和实现分离来解决类的多层次继承结构问题，使得系统更加灵活。
在桥接模式中，有两个关键角色：
2. 抽象类（Abstraction）：定义了抽象部分的接口，通常包含一个成员变量用于持有一个实现对象，并包含抽象方法，这些方法会被委托给实现对象。
3. 实现类（Implementor）：定义了具体实现部分的接口，抽象类中的实现方法都会在这里得以实际实现。
桥接模式的核心思想是将抽象和实现分开，让它们可以独立变化。这种分离使得可以在不修改现有代码的情况下，为系统添加新的抽象部分和实现部分，从而提高系统的可扩展性。

桥接模式的目标是提高系统的灵活性和可维护性，但它也增加了系统的复杂性，因此在设计时需要权衡这些因素。

2. 使用的场景

桥接模式的使用场景包括：

  1. 多维度变化：当一个类具有多个维度的变化，例如抽象部分（Abstraction）和实现部分（Implementor）都有可能变化，但又不希望通过多层次的继承来组合这些变化时，可以使用桥接模式。
  2. 抽象和实现分离：当希望抽象部分和实现部分能够独立地变化和扩展，而不相互影响时，桥接模式可以帮助实现这种分离。
  3. 避免类的爆炸性增长：当有多个维度的变化，并且使用类的继承关系来处理这些变化会导致类的爆炸性增长时，桥接模式可以避免这种情况，使得系统更容易维护和扩展。
  4. 平台无关性：当希望在不同的平台上重用抽象部分和实现部分，并且这些平台之间的实现可能不同，可以使用桥接模式来实现跨平台的兼容性。
  5. 动态切换实现：当需要在运行时动态地选择不同的实现或算法时，桥接模式可以提供一种灵活的方式来切换实现。
  6. 分层结构：在分层结构中，桥接模式可以用来将不同层次的抽象和实现连接起来，以实现整个系统的模块化和可维护性。

总之，桥接模式在多个维度的变化和抽象与实现分离的情况下，可以提供一种灵活、可扩展且易于维护的设计方式。它允许在不同维度上独立地变化和扩展组件，从而提高了系统的可扩展性和可维护性。

3. 应用例子

以下是一个简单的 Python 示例，演示了如何使用桥接模式。假设我们正在构建一个图形编辑器，其中包含不同类型的形状（如矩形和圆形）和不同的颜色（如红色和蓝色），并且希望能够以灵活的方式组合它们。

# 实现部分的接口
class Color:
    def apply_color(self):
        pass

# 具体实现部分 - 红色
class RedColor(Color):
    def apply_color(self):
        return "红色"

# 具体实现部分 - 蓝色
class BlueColor(Color):
    def apply_color(self):
        return "蓝色"

# 抽象部分的接口
class Shape:
    def __init__(self, color):
        self.color = color

    def draw(self):
        pass

# 具体抽象部分 - 矩形
class Rectangle(Shape):
    def draw(self):
        return f"画一个{self.color.apply_color()}的矩形"

# 具体抽象部分 - 圆形
class Circle(Shape):
    def draw(self):
        return f"画一个{self.color.apply_color()}的圆形"

# 客户端代码
red_color = RedColor()
blue_color = BlueColor()

rectangle = Rectangle(red_color)
circle = Circle(blue_color)

print(rectangle.draw())  # 输出：画一个红色的矩形
print(circle.draw())     # 输出：画一个蓝色的圆形

在这个示例中，Color 表示实现部分的接口，具体的颜色实现部分是 RedColor 和 BlueColor。Shape 表示抽象部分的接口，具体的形状实现部分是 Rectangle 和 Circle。客户端代码可以使用不同的颜色和形状来组合图形，而不需要修改现有的类结构，这体现了桥接模式的灵活性。

4. 实现要素

桥接模式的实现要素包括以下部分：

  1. 抽象部分（Abstraction）：定义了抽象部分的接口，通常包含一个成员变量用于持有一个实现对象，并包含抽象方法，这些方法会被委托给实现对象。
  2. 具体抽象部分（Concrete Abstraction）：继承自抽象部分，实现了抽象部分的接口，通常包含一个构造方法用于初始化实现对象。
  3. 实现部分（Implementor）：定义了具体实现部分的接口，抽象部分中的方法都会在这里得以实际实现。
  4. 具体实现部分（Concrete Implementor）：继承自实现部分，实现了实现部分的接口，负责具体的实现逻辑。

5. Java/golang/javascrip/C++ 等语言实现方式

5.1 Java实现

上述例子用Java语言实现示例如下：

// 实现部分的接口
interface Color {
    String applyColor();
}

// 具体实现部分 - 红色
class RedColor implements Color {
    @Override
    public String applyColor() {
        return "红色";
    }
}

// 具体实现部分 - 蓝色
class BlueColor implements Color {
    @Override
    public String applyColor() {
        return "蓝色";
    }
}

// 抽象部分的接口
abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    abstract String draw();
}

// 具体抽象部分 - 矩形
class Rectangle extends Shape {
    public Rectangle(Color color) {
        super(color);
    }

    @Override
    String draw() {
        return "画一个" + color.applyColor() + "的矩形";
    }
}

// 具体抽象部分 - 圆形
class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    @Override
    String draw() {
        return "画一个" + color.applyColor() + "的圆形";
    }
}

public class BridgePatternExample {
    public static void main(String[] args) {
        Color redColor = new RedColor();
        Color blueColor = new BlueColor();

        Shape rectangle = new Rectangle(redColor);
        Shape circle = new Circle(blueColor);

        System.out.println(rectangle.draw());  // 输出：画一个红色的矩形
        System.out.println(circle.draw());     // 输出：画一个蓝色的圆形
    }
}

5.2 Golang实现

上述例子用golang实现示例如下：

package main

import "fmt"

// 实现部分的接口
type Color interface {
        ApplyColor() string
}

// 具体实现部分 - 红色
type RedColor struct{}

func (r *RedColor) ApplyColor() string {
        return "红色"
}

// 具体实现部分 - 蓝色
type BlueColor struct{}

func (b *BlueColor) ApplyColor() string {
        return "蓝色"
}

// 抽象部分的接口
type Shape interface {
        Draw() string
}

// 具体抽象部分 - 矩形
type Rectangle struct {
        color Color
}

func (r *Rectangle) Draw() string {
        return fmt.Sprintf("画一个%s的矩形", r.color.ApplyColor())
}

// 具体抽象部分 - 圆形
type Circle struct {
        color Color
}

func (c *Circle) Draw() string {
        return fmt.Sprintf("画一个%s的圆形", c.color.ApplyColor())
}

func main() {
        redColor := &RedColor{}
        blueColor := &BlueColor{}

        rectangle := &Rectangle{color: redColor}
        circle := &Circle{color: blueColor}

        fmt.Println(rectangle.Draw()) // 输出：画一个红色的矩形
        fmt.Println(circle.Draw())    // 输出：画一个蓝色的圆形
}

5.3 Javascript实现

上述例子用javascript实现示例如下：

// 实现部分的接口
class Color {
  applyColor() {
    return "";
  }
}

// 具体实现部分 - 红色
class RedColor extends Color {
  applyColor() {
    return "红色";
  }
}

// 具体实现部分 - 蓝色
class BlueColor extends Color {
  applyColor() {
    return "蓝色";
  }
}

// 抽象部分的接口
class Shape {
  constructor(color) {
    this.color = color;
  }

  draw() {}
}

// 具体抽象部分 - 矩形
class Rectangle extends Shape {
  draw() {
    return `画一个${this.color.applyColor()}的矩形`;
  }
}

// 具体抽象部分 - 圆形
class Circle extends Shape {
  draw() {
    return `画一个${this.color.applyColor()}的圆形`;
  }
}

// 客户端代码
const redColor = new RedColor();
const blueColor = new BlueColor();

const rectangle = new Rectangle(redColor);
const circle = new Circle(blueColor);

console.log(rectangle.draw()); // 输出：画一个红色的矩形
console.log(circle.draw());    // 输出：画一个蓝色的圆形

5.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <string>

// 实现部分的接口
class Color {
public:
    virtual std::string applyColor() = 0;
};

// 具体实现部分 - 红色
class RedColor : public Color {
public:
    std::string applyColor() override {
        return "红色";
    }
};

// 具体实现部分 - 蓝色
class BlueColor : public Color {
public:
    std::string applyColor() override {
        return "蓝色";
    }
};

// 抽象部分的接口
class Shape {
protected:
    Color* color;

public:
    Shape(Color* color) : color(color) {}

    virtual std::string draw() = 0;
};

// 具体抽象部分 - 矩形
class Rectangle : public Shape {
public:
    Rectangle(Color* color) : Shape(color) {}

    std::string draw() override {
        return "画一个" + color->applyColor() + "的矩形";
    }
};

// 具体抽象部分 - 圆形
class Circle : public Shape {
public:
    Circle(Color* color) : Shape(color) {}

    std::string draw() override {
        return "画一个" + color->applyColor() + "的圆形";
    }
};

int main() {
    Color* redColor = new RedColor();
    Color* blueColor = new BlueColor();

    Shape* rectangle = new Rectangle(redColor);
    Shape* circle = new Circle(blueColor);

    std::cout << rectangle->draw() << std::endl; // 输出：画一个红色的矩形
    std::cout << circle->draw() << std::endl;    // 输出：画一个蓝色的圆形

    delete redColor;
    delete blueColor;
    delete rectangle;
    delete circle;

    return 0;
}

6. 练习题

假设你正在开发一个图形编辑器应用程序，并且你希望支持不同的操作系统（如 Windows、macOS 和 Linux）和不同的绘图库（如 OpenGL 和 DirectX）。使用桥接模式设计一个系统，使得你可以轻松地添加新的操作系统和绘图库的组合，同时确保它们能够协同工作。

要求：

  1. 创建一个抽象类 OperatingSystem，它包含一个抽象方法 draw() 用于绘制图形。
  2. 创建具体的操作系统类，如 WindowsOS 和 MacOS，它们继承自 OperatingSystem 并实现 draw() 方法。
  3. 创建一个抽象类 GraphicsLibrary，它包含一个抽象方法 render() 用于渲染图形。
  4. 创建具体的绘图库类，如 OpenGLLibrary 和 DirectXLibrary，它们继承自 GraphicsLibrary 并实现 render() 方法。
  5. 创建一个 Shape 类，它包含一个成员变量 os（表示操作系统）和一个成员变量 graphics（表示绘图库）。它还包含一个抽象方法 drawShape()，该方法在操作系统上绘制图形使用绘图库。
  6. 创建具体的图形类，如 Circle 和 Rectangle，它们继承自 Shape 并实现 drawShape() 方法，以便在指定的操作系统上使用指定的绘图库绘制图形。
  7. 最后，创建一个客户端应用程序，演示如何使用桥接模式创建不同的操作系统和绘图库组合，以绘制不同的图形。

你可以使用 C++、Java、Python 或任何其他编程语言来实现这个练习。
你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
专栏目录
设计模式——桥接模式
weixin_46073538的博客
07-16 787
现在有一个需求，需要创建不同的图形，并且每个图形都有可能会有不同的颜色。我们可以利用继承的方式来设计类的关系：我们可以发现有很多的类，假如我们再增加一个形状或再增加一种颜色，就需要创建更多的类。试想，在一个有多种可能会变化的维度的系统中，用继承方式会造成类爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类。为了更加灵活的设计系统，我们此时可以考虑使用桥接模式。定义：将抽象与实现分离，使它们可以独立变化。
大话设计模式——11.桥接模式（Bridge Pattern）
a1498665771的博客
04-08 730
将抽象部分与它的实现部分分离，使它们可以独立变化。UML图：系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性不想使用继承导致系统类的个数急剧增加某个类存在多个变化维度使用继承方式容易出现类的膨胀优点实现抽象和实现的分离，提高系统灵活性具备良好的扩展性，符合开闭原则缺点增加系统的理解和设计难度。
C++设计模式——Bridge桥接模式
CoderZZ_2024的博客
06-14 1361
设计模式入门
设计模式——桥接模式详解
qq_45944185的博客
03-13 6918
一文搞定桥接模式，拒绝标题党
C++ 设计模式——桥接模式
qq_68194402的博客
08-29 1169
桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，使它们都可以独立地变化。这种模式通过组合的方式来代替继承，增加了系统的灵活性。
设计模式——Bridge(桥接模式)
qq_36566262的博客
04-17 668
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 Java实际应用举例4.1 Abstraction——DriverManager4.2 Implementer——java.sql.Driver4.3 ConcreteImplementer——com.mysql.cj.jdbc.Driver5 总结参考文献 前言 如果实现一个跨平台的软件，那么如何处理与平台有关的部分和与平台无关部分，也就是抽象和实现的关系，这里就涉及到Bridge桥接模式了。 1 定义 将抽象部分和实现部分分离，使他们可以
Java设计模式——桥接模式
leyasuzhou的博客
11-23 405
1。实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开，有助于系统进行分层设计，从而产生更好的结构化系统2.对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其他的部分由具体业务来完成3.桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本4.桥接模式的引入增加了系统的理解和设计难度，由于聚合关系建立在抽象层，要求开发者针对抽象进行设计和编程。
【19】c++设计模式——＞桥接模式
weixin_42097108的博客
10-08 637
C++的桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使得它们可以独立地变化。桥接模式的核心思想是利用组合关系代替继承关系，将系统划分成多个独立的、功能不同的类层次结构，并通过桥接类将它们连接起来。在桥接模式中，有两个重要的概念：抽象化（Abstraction）和实现化（Implementation），它们分别对应了系统的抽象部分和实现部分。抽象化负责定义接口，并维护一个指向实现化对象的指针；实现化则负责定义具体的实现方法。
设计模式——结构类——桥接模式
tingxuejianghu的博客
05-19 460
一、理论 Decouple an abstraction from its implementation so that the two can vary independently. 将抽象和实现解耦，使得两者可以独立地变化。 Bridge 模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展。 Abstraction——抽象化
设计模式——Bridge(桥接)模式
༺ bestcxx的专栏 ༻
07-01 388
桥接模式用于将接口定义与逻辑实现进行分离。 单凭这一句容易让人产生费解，事实上，桥接模式是将接口的实现通过构造方法传递给调用者，而在调用者这边也可以进行一次抽象。
设计模式——JAVA.docx
04-03
### JAVA设计模式总结之23种设计模式及六大原则 #### 一、设计模式之六大原则 ##### 总原则：开闭原则（Open Close Principle） 开闭原则是设计模式中最核心的原则之一，它强调的是软件实体（类、模块、函数等）...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
C++实现开发模式——Bridge(桥接)模式
yxh_1_的博客
04-24 716
C++实现开发模式——Bridge(桥接)模式 桥接模式是什么？ 桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。 桥接（Bridge）模式的优点是： 抽象与实现分离，扩展能力强 符合开闭原则 符合合成复用原则 其实现细节对客户透明 缺点是：由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。 为什么要用桥接模式
设计模式、系统设计 record part02
最新发布
m0_47505062的博客
09-27 775
软件设计模式1.应对重复发生的问题2.解决方案3.可以反复使用1.本质是面向对象2.优点很多1.创建型-创建和使用分离2.结构型-组合3.行为型-协作5+7+11=23种模式UML-统一建模语言-Unified Modeling Language1.可视化图形化2.各种图（9种图）3.可以同时表示静态信息、动态信息类图就是图形化显式类关联关系。
设计模式的分类
SunnyRivers
09-25 966
设计模式，即Design Patterns，是指在软件设计中，被反复使用的一种代码设计经验。使用设计模式的目的是为了可重用代码，提高代码的可扩展性和可维护性。设计模式这个术语是上个世纪90年代由Erich Gamma、Richard Helm、Raplh Johnson和Jonhn Vlissides四个人总结提炼出来的，并且写了一本Design Patterns的书。这四人也被称为四人帮（GoF）。为什么要使用设计模式？
超详细超实用！！！AI编程之cursor编写设计模式接口隔离原则实例（七）
qq_43206280的博客
09-25 669
客户端不应该被迫依赖于它不使用的方法，一个类对另一个类的依赖应该建立在最小的接口上。要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。
设计模式总览
我的博客
09-22 856
设计模式主要分为以下三大类：创建型模式（Creational Patterns）结构型模式（Structural Patterns）行为型模式（Behavioral Patterns）
设计模式之模板方法模式
一个老Java开发的自白
09-24 771
模板方法模式是一种非常有用的设计模式，它通过定义算法的框架，将算法中的一些步骤延迟到子类中实现，从而在不改变算法结构的前提下，允许子类灵活地定义算法的具体步骤。这种模式在软件开发中广泛应用于需要固定算法结构但某些步骤实现可能变化的场合，如框架和库的设计、业务流程的处理等。通过模板方法模式，我们可以提高代码的复用性、灵活性和可扩展性，同时保持算法结构的稳定性。
前端开发设计模式——单例模式
jxnd123456的博客
09-27 947
单例模式是一种创建型设计模式，它保证一个类只有一个示例，并提供一个访问它的全局访问点。
研磨设计模式——Java实战解析
"研磨设计模式(Java)" 是一本由JAVA开发者chjavach编写的关于设计模式的书籍，主要探讨了Java编程中的设计模式应用，包括单例模式、工厂方法模式、策略模式、命令模式和桥接模式。该书通过一系列的文章在JavaEye社区...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值