概述
设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等，此时至少有如下两种设计方案：
- 第一种设计方案是为每一种形状都提供一套各种颜色的版本。
- 第二种设计方案是根据实际需要对形状和颜色进行组合
对于有两个变化维度（即两个变化的原因）的系统，采用方案二来进行设计系统中类的个数更少，且系统扩展更为方便。设计方案二即是桥接模式的应用。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。
定义
将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体(
Handle and Body)模式或接口(Interface)模式。
角色
Abstraction：抽象类RefinedAbstraction：扩充抽象类Implementor：实现类接口ConcreteImplementor：具体实现类
场景
- 想要避免抽象及其实现之间的永久绑定
- 抽象及其实现都应该可以通过子类扩展
- 抽象实现的更改不应对客户端产生影响
- 想完全向客户端隐藏抽象的实现
实现一
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//抽象实现类 class Implementor { public: virtual ~Implementor() {} virtual void action() = 0; //... }; //具体实现类A class ConcreteImplementorA : public Implementor { public: ~ConcreteImplementorA() {} void action() { std::cout << "Concrete Implementor A" << std::endl; } //... }; //具体实现类B class ConcreteImplementorB : public Implementor { public: ~ConcreteImplementB() {} void action() { std::cout << "Concrete Implementor B" << std::endl; } //... }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//抽象类 class Abstraction { public: virtual ~Abstraction() {} virtual void operation() = 0; //... }; //扩充抽象类 class RefinedAbstraction : public Abstraction { public: ~RefinedAbstraction() {} RefinedAbstraction(Implementor * impl):implementor(impl) {} void operation() { implementor->action(); } //... private: Implementor * implementor; }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
auto main()->int { Implementor * ia = new ConcreteImplementorA; Implementor * ib = new ConcreteImplementorB; Abstraction * abstract1 = new RefinedAbstraction(ia); abstract1->operation(); Abstraction * abstract2 = new RefinedAbstraction(ib); abstract2->operation(); delete abstract1; delete abstract2; delete ia; delete ib; return 0; } |
实现二
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
#include <iostream> // Implementor: 颜色接口 class Color { public: virtual void applyColor() = 0; }; // ConcreteImplementor: 红色实现类 class RedColor : public Color { public: void applyColor() override { std::cout << "Applying red color." << std::endl; } }; // ConcreteImplementor: 蓝色实现类 class BlueColor : public Color { public: void applyColor() override { std::cout << "Applying blue color." << std::endl; } }; // Abstraction: 形状抽象类 class Shape { protected: Color* color; // 维护颜色的引用 public: Shape(Color* color) : color(color) {} virtual void draw() = 0; }; // RefinedAbstraction: 矩形类 class Rectangle : public Shape { public: Rectangle(Color* color) : Shape(color) {} void draw() override { std::cout << "Drawing a rectangle. "; color->applyColor(); } }; // RefinedAbstraction: 圆形类 class Circle : public Shape { public: Circle(Color* color) : Shape(color) {} void draw() override { std::cout << "Drawing a circle. "; color->applyColor(); } }; int main() { Color* red = new RedColor(); Color* blue = new BlueColor(); Shape* redRectangle = new Rectangle(red); Shape* blueCircle = new Circle(blue); redRectangle->draw(); // Drawing a rectangle. Applying red color. blueCircle->draw(); // Drawing a circle. Applying blue color. delete red; delete blue; delete redRectangle; delete blueCircle; return 0; } |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ 结构型：装饰器模式09/19
- ♥ 行为型：备忘录模式09/25
- ♥ 行为型：责任链模式09/25
- ♥ 行为型：状态模式09/24
- ♥ 设计模式:六大原则04/18
- ♥ 结构型：委托模式07/28