设计模式笔记(8)—桥接模式（结构型） Gof定义 将抽象部分与实现部分分离，使他们都可以独立地变化。
先来看一个简单的例子，假设我们需要开发一个同时支持PC和手机的坦克游戏，游戏在PC和手机上的功能都一样，有同样的类型，有同样的功能需求变化，而这些游戏中的坦克有多种不同的型号：T50 T60等。根据面向对象的思想，我们可以很容易设计一个坦克(Tank)的抽象类，然后不同的型号都继承抽象类，并且PC和手机上的图形绘制，操作等都是不相同的，所以不同的平台都要提供自己的一套实现：
坦克抽象类
1 2 3 4 5 6 7 8 /// <summary> /// 坦克的抽象类 /// </summary> public abstract class Tank { public abstract void Start(); public abstract void Attack(); }
各种不同的型号
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /// <summary> /// T50型号 /// </summary> public class T50:Tank { public override void Attack(){} public override void Start(){} } /// <summary> /// T60型号 /// </summary> public class T60:Tank { public override void Attack(){} public override void Start(){} }
手机上的实现
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 /// <summary> /// MobileT50型号 /// </summary> public class MobileT50 : T50 { /// <summary> /// 启动 /// </summary> public override void Start(){} /// <summary> /// 攻击 /// </summary> public override void Attack(){} } /// <summary> /// MobileT60型号 /// </summary> public class MobileT60 : Tank { /// <summary> /// 启动 /// </summary> public override void Start(){} /// <summary> /// 攻击 /// </summary> public override void Attack(){} }
PC上的实现
1 2 3 4 5 6 7 8 public class PCT50 : T50 { //代码和手机中的类似 } public class PCT60 : T60 { //代码和手机中的类似 }
客户端调用
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 /// <summary> /// 手机客户端调用 /// </summary> public class MobileApp { void Main(string[] args) { Tank t; t = new MobileT50(); t.Start(); t.Attack(); t = new MobileT60(); t.Start(); t.Attack(); } } /// <summary> /// PC客户端调用 /// </summary> public class PCApp { void Main(string[] args) { //... } }
这样的设计在需求比较稳定的情况下并没有什么问题，但事情往往不是这样，我们可以有更多的型号如T80、T90、T100等，而且平台也可能不止手机和PC这两种，可能还有PSP，掌上电脑等。当有这样双向需求变化的时候，如果还像上面这样设计将会带来很多的问题，会有更多的重复代码，类之间的结构也变得非常复杂，新添加一个平台和加几种型号都会很麻烦。如下图：
动机 思考下上面问题：事实上由于Tank的类型的固有逻辑，使得Tank类型具有了两个变化的维度—“平台的变化”和“型号的变化”。如何应对这种“多维度的变化”？如何利用面向对象技术来使Tank类型可以轻松沿着“平台”和“型号”两个方向变化，而不引入额外的复杂度？这就是桥接模式要解决的问题。
既然涉及到了两个维度的变化，那么我们就这对这两个维度来涉及抽象类，然后再想办法将其关联起来，先来创建“平台”和“型号”的抽象类，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /// <summary> /// 坦克型号的抽象类 /// </summary> public abstract class TankModel { public abstract void Run(); } /// <summary> /// 平台的抽象类 /// </summary> public abstract class TankPlatformImplementation { public abstract void MoveTankTo(int x,int y); public abstract void DrawTank(); public abstract void Attack(); }
现在通过组合的方式将两个类关联起来，修改坦克型号的类即可，修改后的代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /// <summary> /// 坦克型号的抽象类 /// </summary> public abstract class TankModel { protected TankPlatformImplementation _tankImp; /// <summary> /// 构造函数中传入平台对象 /// </summary> /// <param name="tankImp"></param> public TankModel(TankPlatformImplementation tankImp) { _tankImp = tankImp; } public abstract void Run(); }
抽象类已经完成，现在假设有PC平台和T50型号的坦克，实现如下：
PC平台具体类
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 /// <summary> /// PC坦克 /// </summary> public class PCTankImplatation:TankPlatformImplementation { string _tankModel; public PCTankImplatation(string tankModel) { _tankModel = tankModel; } /// <summary> /// 绘制坦克 /// </summary> public override void DrawTank() { Console.WriteLine(_tankModel+"PC坦克绘制成功！"); } /// <summary> /// 坦克移动 /// </summary> /// <param name="x">x坐标</param> /// <param name="y">y坐标</param> public override void MoveTankTo(int x, int y) { Console.WriteLine(_tankModel+"PC坦克已经移动到了坐标("+x+","+y+")处"); } /// <summary> /// 攻击 /// </summary> public override void Attack() { Console.WriteLine(_tankModel+"PC坦克开始攻击"); } }
T50型号坦克具体类
1 2 3 4 5 6 7 8 9 10 11 12 13 /// <summary> /// T50型号坦克 /// </summary> public class T50 : TankModel { public T50(TankPlatformImplementation tankImp) : base(tankImp) { } public override void Run() { _tankImp.DrawTank(); _tankImp.MoveTankTo(100, 100); _tankImp.Attack(); } }
客户端调用
1 2 3 4 5 6 7 8 9 10 11 /// <summary> /// 客户端调用 /// </summary> public class App { void Main(string[] agrs) { T50 t = new T50(new PCTankImplatation()); t.Run(); } }
至此桥接模式的代码部分基本完成，主要是同过在抽象类中的组合方式来实现，下面看下桥接模式的结构图：
使用了桥接模式后，当需求发生变化后就很容易来应对了，假如现在又多了一种T60型号的坦克，并且添加了一个手机平台。只需要添加T60型号的具体类和手机平台具体类即可，如下：
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 /// <summary> /// 手机坦克 /// </summary> public class MobileTankImplatation : TankPlatformImplementation { string _tankModel; public MobileTankImplatation(string tankModel) { _tankModel = tankModel; } /// <summary> /// 绘制坦克 /// </summary> public override void DrawTank() { Console.WriteLine(_tankModel+"Mobile坦克绘制成功！"); } /// <summary> /// 坦克移动 /// </summary> /// <param name="x">x坐标</param> /// <param name="y">y坐标</param> public override void MoveTankTo(int x, int y) { Console.WriteLine(_tankModel+"Mobile坦克已经移动到了坐标(" + x + "," + y + ")处"); } /// <summary> /// 攻击 /// </summary> public override void Attack() { Console.WriteLine(_tankModel+"Mobile坦克开始攻击"); } } /// <summary> /// T60型号坦克 /// </summary> public class T60 : TankModel { public T60(TankPlatformImplementation tankImp) : base(tankImp) { } public override void Run() { _tankImp.DrawTank(); _tankImp.MoveTankTo(400, 100); _tankImp.Attack(); } }
添加这两个类后现在我们有T50型号、 T60型号 、PC平台、手机平台，虽然只添加了两个类，但现在有了四种组合，看客户端代码的调用：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 /// <summary> /// 客户端调用 /// </summary> public class App { void Main(string[] agrs) { //T50在PC上 T50 t50PC = new T50(new PCTankImplatation("T50")); t50PC.Run(); //T50在Mobile上 T50 t50Mobile = new T50(new MobileTankImplatation("T50")); t50Mobile.Run(); //T60在PC上 T60 t60PC = new T60(new PCTankImplatation("T60")); t60PC.Run(); //T60在Mobile上 T60 t60Mobile = new T60(new MobileTankImplatation("T60")); t60Mobile.Run(); } }
运行结果如下：
如果再有不同的平台或是不同型号添加，只需添加平台和型号的具体类实现就可以了，关于什么型号在什么平台上使用，可以在调用的时候随意组合。这样就大大减少了类的结构的复杂度，下面两幅图就是最好的说明。
没有使用桥接模式时的需求变化
使用桥接模式后的需求变化
桥接模式的几个要点
桥接模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象（Tank的型号）和实现（不同的平台）可以沿着各自的维度来变化。
所谓抽象和实现沿着各自维度的变化，即“子类化”他们，比如不同的Tank型号的子类，和不同平台的子类。得到各个子类之后，便可以任意组合他们，从而获得不同平台上的不同型号。
桥接模式有时候类似于多继承方案，但是多继承方案往往违背了单一职责原则，复用性比较差。桥接模式是比多继承方案更好的方法。
桥接模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈—换言之两个变化不会导致从横交错的结果，并不一定要使用桥接模式。
返回开篇（索引）
