桥接模式将抽象(Abstraction)与实现(Implementation)分离，使得二者可以独立地变化。

桥接模式典型的结构图为：

在桥接模式的结构图中可以看到，系统被分为两个相对独立的部分，左边是抽象部分，右边是实现部分，这两个部分可以互相独立地进行修改：例如上面问题中的客户需求变化，当用户需求需要从 Abstraction 派生一个具体子类时候，并不需要像上面通过继承方式实现时候需要添加子类 A1 和 A2 了。另外当上面问题中由于算法添加也只用改变右边实现（添加一个具体化子类），而右边不用在变化，也不用添加具体子类了。

一切都变得 elegant！

桥接模式号称设计模式中最难理解的模式之一，关键就是这个抽象和实现的分离非常让人奇怪，大部分人刚看到这个定义的时候都会认为实现就是继承自抽象，那怎么可能将他们分离呢。

《大话设计模式》中就Bridge模式的解释：

手机品牌和软件是两个概念，不同的软件可以在不同的手机上，不同的手机可以有相同的软件，两者都具有很大的变动性。如果我们单独以手机品牌或手机软件为基类来进行继承扩展的话，无疑会使类的数目剧增并且耦合性很高，（如果更改品牌或增加软件都会增加很多的变动）两种方式的结构如下：

所以将两者抽象出来两个基类分别是PhoneBrand和PhoneSoft，那么在品牌类中聚合一个软件对象的基类将解决软件和手机扩展混乱的问题，这样两者的扩展就相对灵活，剪短了两者的必要联系，结构图如下：

这样扩展品牌和软件就相对灵活独立，达到解耦的目的！

抽象基类及接口：

1、Abstraction::Operation()：定义要实现的操作接口

2、AbstractionImplement::Operation()：实现抽象类Abstaction所定义操作的接口，由其具体派生类ConcreteImplemenA、ConcreteImplemenA或者其他派生类实现。

3、在Abstraction::Operation()中根据不同的指针多态调用AbstractionImplement::Operation()函数。

理解:
Bridge用于将表示和实现解耦,两者可以独立的变化.在Abstraction类中维护一个AbstractionImplement类指针,需要采用不同的实现方式的时候只需要传入不同的AbstractionImplement派生类就可以了.

Bridge的实现方式其实和Builde十分的相近,可以这么说:本质上是一样的,只是封装的东西不一样罢了.两者的实现都有如下的共同点:

抽象出来一个基类,这个基类里面定义了共有的一些行为,形成接口函数(对接口编程而不是对实现编程),这个接口函数在Buildier中是BuildePart函数在Bridge中是Operation函数;

其次,聚合一个基类的指针,如Builder模式中Director类聚合了一个Builder基类的指针,而Brige模式中Abstraction类聚合了一个AbstractionImplement基类的指针(优先采用聚合而不是继承);

而在使用的时候,都把对这个类的使用封装在一个函数中,在Bridge中是封装在Director::Construct函数中,因为装配不同部分的过程是一致的,而在Bridge模式中则是封装在Abstraction::Operation函数中,在这个函数中调用对应的AbstractionImplement::Operation函数.就两个模式而言,Builder封装了不同的生成组成部分的方式,而Bridge封装了不同的实现方式.

桥接模式就将实现与抽象分离开来，使得RefinedAbstraction依赖于抽象的实现，这样实现了依赖倒转原则，而不管左边的抽象如何变化，只要实现方法不变，右边的具体实现就不需要修改，而右边的具体实现方法发生变化，只要接口不变，左边的抽象也不需要修改。

优点
1.将实现抽离出来，再实现抽象，使得对象的具体实现依赖于抽象，满足了依赖倒转原则。

2.将可以共享的变化部分，抽离出来，减少了代码的重复信息。

3.对象的具体实现可以更加灵活，可以满足多个因素变化的要求。

缺点
客户必须知道选择哪一种类型的实现。
设计中有超过一维的变化我们就可以用桥模式。如果只有一维在变化，那么我们用继承就可以圆满的解决问题。

代码示例：

Abstraction.h

? 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 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 #ifndef _ABSTRACTION_H_ #define _ABSTRACTION_H_ class AbstractionImplement; class Abstraction { public: virtual void Operation()=0;//定义接口，表示该类所支持的操作 virtual ~Abstraction(); protected: Abstraction(); }; class RefinedAbstractionA:public Abstraction { public: RefinedAbstractionA(AbstractionImplement* imp);//构造函数 virtual void Operation();//实现接口 virtual ~RefinedAbstractionA();//析构函数 private: AbstractionImplement* _imp;//私有成员 }; class RefinedAbstractionB:public Abstraction { public: RefinedAbstractionB(AbstractionImplement* imp);//构造函数 virtual void Operation();//实现接口 virtual ~RefinedAbstractionB();//析构函数 private: AbstractionImplement* _imp;//私有成员 }; #endif Abstraction.cpp #include "Abstraction.h" #include "AbstractionImplement.h" #include <iostream> using namespace std; Abstraction::Abstraction() {} Abstraction::~Abstraction() {} RefinedAbstractionA::RefinedAbstractionA(AbstractionImplement* imp) { this->_imp = imp; } RefinedAbstractionA::~RefinedAbstractionA() { delete this->_imp; this->_imp = NULL; } void RefinedAbstractionA::Operation() { cout << "RefinedAbstractionA::Operation" << endl; this->_imp->Operation(); } RefinedAbstractionB::RefinedAbstractionB(AbstractionImplement* imp) { this->_imp = imp; } RefinedAbstractionB::~RefinedAbstractionB() { delete this->_imp; this->_imp = NULL; } void RefinedAbstractionB::Operation() { cout << "RefinedAbstractionB::Operation" << endl; this->_imp->Operation(); } AbstractImplement.h #ifndef _ABSTRACTIONIMPLEMENT_H_ #define _ABSTRACTIONIMPLEMENT_H_ //抽象基类，定义了实现的接口 class AbstractionImplement { public: virtual void Operation()=0;//定义操作接口 virtual ~AbstractionImplement(); protected: AbstractionImplement(); }; // 继承自AbstractionImplement,是AbstractionImplement的不同实现之一 class ConcreteAbstractionImplementA:public AbstractionImplement { public: ConcreteAbstractionImplementA(); void Operation();//实现操作 ~ConcreteAbstractionImplementA(); protected: }; // 继承自AbstractionImplement,是AbstractionImplement的不同实现之一 class ConcreteAbstractionImplementB:public AbstractionImplement { public: ConcreteAbstractionImplementB(); void Operation();//实现操作 ~ConcreteAbstractionImplementB(); protected: }; #endif AbstractImplement.cpp #include "AbstractionImplement.h" #include <iostream> using namespace std; AbstractionImplement::AbstractionImplement() {} AbstractionImplement::~AbstractionImplement() {} ConcreteAbstractionImplementA::ConcreteAbstractionImplementA() {} ConcreteAbstractionImplementA::~ConcreteAbstractionImplementA() {} void ConcreteAbstractionImplementA::Operation() { cout << "ConcreteAbstractionImplementA Operation" << endl; } ConcreteAbstractionImplementB::ConcreteAbstractionImplementB() {} ConcreteAbstractionImplementB::~ConcreteAbstractionImplementB() {} void ConcreteAbstractionImplementB::Operation() { cout << "ConcreteAbstractionImplementB Operation" << endl; }

main.cpp

? 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 #include "Abstraction.h" #include "AbstractionImplement.h" #include <iostream> using namespace std; int main() { AbstractionImplement* imp = new ConcreteAbstractionImplementA(); //实现部分ConcreteAbstractionImplementA Abstraction* abs = new RefinedAbstractionA(imp); //抽象部分RefinedAbstractionA abs->Operation(); cout << "-----------------------------------------" << endl; AbstractionImplement* imp1 = new ConcreteAbstractionImplementB(); //实现部分ConcreteAbstractionImplementB Abstraction* abs1 = new RefinedAbstractionA(imp1); //抽象部分RefinedAbstractionA abs1->Operation(); cout << "-----------------------------------------" << endl; AbstractionImplement* imp2 = new ConcreteAbstractionImplementA(); //实现部分ConcreteAbstractionImplementA Abstraction* abs2 = new RefinedAbstractionB(imp2); //抽象部分RefinedAbstractionB abs2->Operation(); cout << "-----------------------------------------" << endl; AbstractionImplement* imp3 = new ConcreteAbstractionImplementB(); //实现部分ConcreteAbstractionImplementB Abstraction* abs3 = new RefinedAbstractionB(imp3); //抽象部分RefinedAbstractionB abs3->Operation(); cout << endl; return 0; }

代码说明：
Bridge模式将抽象和实现分别独立实现，在代码中就是Abstraction类和AbstractionImplement类。

使用组合（委托）的方式将抽象和实现彻底地解耦，这样的好处是抽象和实现可以分别独立地变化，系统的耦合性也得到了很好的降低。
GoF的那句话中的“实现”该怎么去理解：“实现”特别是和“抽象”放在一起的时候我们“默认”的理解是“实现”就是“抽象”的具体子类的实现，但是这里GoF所谓的“实现”的含义不是指抽象基类的具体子类对抽象基类中虚函数（接口）的实现，是和继承结合在一起的。而这里的“实现”的含义指的是怎么去实现用户的需求，并且指的是通过组合（委托）的方式实现的，因此这里的实现不是指的继承基类、实现基类接口，而是指的是通过对象组合实现用户的需求。

实际上上面使用Bridge模式和使用带来问题方式的解决方案的根本区别在于是通过继承还是通过组合的方式去实现一个功能需求。

备注：

由于实现的方式有多种，桥接模式的核心就是把这些实现独立出来，让他们各自变化。

将抽象部分与它的实现部分分离：实现系统可能有多角度（维度）分类，每一种分类都可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。

在发现需要多角度去分类实现对象，而只用继承会造成大量的类增加，不能满足开放-封闭原则时，就要考虑用Bridge桥接模式了。

合成/聚合复用原则：尽量使用合成/聚合，精良不要使用类继承。
优先使用对象的合成/聚合将有助于保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。

适用场景：

• 你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。
• 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时B r i d g e 模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
• 对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
• （C + +）你想对客户完全隐藏抽象的实现部分。在C + +中，类的表示在类接口中是可见的。
• 有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。R u m b a u g h 称这种类层次结构为“嵌套的普化”（nested generalizations ）。
• 你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。一个简单的例子便是C o p l i e n 的S t r i n g 类[ C o p 9 2 ]，在这个类中多个对象可以共享同一个字符串表示（S t r i n g R e p ）。