GOF之桥接模式

引入问题：

假如我们需要开发一个同事支持PC和手机的坦克游戏，游戏在PC和手机上功能都一样，都有同样的类型，面临同样的功能需求变化，比如坦克可能有多种不同的型号：T50，T75，T90...

但是PC和手机上的图形绘制、声效、操作等实现完全不同...因此对于各种型号的坦克，都要提供不同平台上的坦克实现。

动机(Motivation)

思考上述问题的症结：事实上由于Tank类型的固有逻辑，使得Tank类型具有了两个变化的维度---一个变化的维度为“平台的变化”，一个变化的维度为“型号的变化”。

如何应对这种“多维度的变化”？如何利用面向对象技术来使得Tank类型可以轻松地沿着“平台”和“型号”两个方向变化，而不引入额外的复杂度？

意图(Intent)

将抽象部分与实现部分分离，使它们都可以独立的变化。

结构(Structure)

代码实现：

一种维度的变化
 public abstract class TankPlatformImplementation
    {
        public abstract void MoveTo();
        public abstract void DrawTank();
        public abstract void DoShot();
    }

    public class PCTankImplementation : TankPlatformImplementation
    {

        public override void MoveTo()
        {
            Console.WriteLine("PC端移动");
        }

        public override void DrawTank()
        {
            Console.WriteLine("PC端画坦克");
        }

        public override void DoShot()
        {
            Console.WriteLine("PC端攻击");
        }
    }

    public class MobileTankImplementation : TankPlatformImplementation
    {

        public override void MoveTo()
        {
            Console.WriteLine("移动端移动");
        }

        public override void DrawTank()
        {
            Console.WriteLine("移动端画坦克");
        }

        public override void DoShot()
        {
            Console.WriteLine("移动端攻击");
        }
    }

另一种维度的变化
 public abstract class Tank
    {
        protected TankPlatformImplementation tpimp;
        public abstract void Run();
        public abstract void Stop();
    }

    public class T50 : Tank
    {
        public T50(TankPlatformImplementation tpimp)
        {
            this.tpimp = tpimp;
        }
        public void MoveTo()
        {
            Console.Write("T50的");
            tpimp.MoveTo();            
        }
        public void DoShot()
        {
            Console.Write("T50的");
            tpimp.DoShot();
        }
        public void DrawTank()
        {
            Console.Write("T50的");
            tpimp.DrawTank();
        }


        public override void Run()
        {
            Console.WriteLine("T50跑");
        }

        public override void Stop()
        {
            Console.WriteLine("T50停");
        }
    }
    public class T75 : Tank
    {
    public T75(TankPlatformImplementation tpimp)
        {
            this.tpimp = tpimp;
        }
        public void MoveTo()
        {
            Console.Write("T75的");
            tpimp.MoveTo();
        }
        public void DoShot()
        {
            Console.Write("T75的");
            tpimp.DoShot();
        }
        public void DrawTank()
        {
            Console.Write("T75的");
            tpimp.DrawTank();
        }

        public override void Run()
        {
            Console.WriteLine("T75跑");
        }

        public override void Stop()
        {
            Console.WriteLine("T75停");
        }
    }
    public class T90 : Tank
    { 
    public T90(TankPlatformImplementation tpimp)
        {           
            this.tpimp = tpimp;
        }
        public void MoveTo()
        {
            Console.Write("T90的");
            tpimp.MoveTo();
        }
        public void DoShot()
        {
            Console.Write("T90的");
            tpimp.DoShot();
        }
        public void DrawTank()
        {
            Console.Write("T90的");
            tpimp.DrawTank();
        }

        public override void Run()
        {
            Console.WriteLine("T90跑");
        }

        public override void Stop()
        {
            Console.WriteLine("T90停");
        }
    }

主函数的调用
 static void Main(string[] args)
        {
            T75 tank = new T75(new MobileTankImplementation());
            tank.DrawTank();
            tank.DoShot();
            tank.MoveTo();
            tank.Run();
            tank.Stop();
            Console.ReadKey();
        }

Bridge模式的几个要点：

Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象(Tank的型号)和实现(不同的平台)可以沿着各自的维度来变化。

所谓抽象和实现沿着各自的维度的变化，即“子类化”它们，比如不同的Tank型号子类，和不同的平台子类。得到各个子类之后，便可以任意组合它们，从而获得 不同平台上的不同型号。

Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则(即一个类只有一个变化的原因)，复用性较差。Bridge模式是比多继承方案更好的解决方法。

Bridge模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈--换言之两个变化不会导致纵横交错的结果，并不一定要使用Bridge模式。