设计模式：Bridge

备注：包含两种示例，一种是类图直译场景以便理解类图，另一种是伪现实场景以便应用。

Bridge Pattern：桥接模式，【GOF95】将抽象化 (Abstraction)与实现化(Implementation)解耦，使得二者可以独立地变化。

将两个角色之间的继承关系改为聚合关系，即强关联改为弱关联。因此，桥梁模式中的所谓解耦，就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以相对独立地变化。

1、Class diagram：

2、Example（C#）

类图直译场景：Abstraction抽象分支扩展1/2，Implementor实现分支扩展A/B。

伪现实场景：大中小号毛笔 沾七彩颜料进行画图。

using System;

namespace Tom.Dp
{
    class BridgeClient
    {
        static void Main(string[] args)
        {
            BridgeClient.Run();
            BridgeClient.Run2();
            BridgeClient.ShowConsoleColor();

            /*output
            类图直译场景-----
            -----0：RefinedAbstraction1 & ConcreteImplementorA.OpertionImp
            -----1：RefinedAbstraction1 & ConcreteImplementorB.OpertionImp
            -----2：RefinedAbstraction2 & ConcreteImplementorA.OpertionImp
            -----3：RefinedAbstraction2 & ConcreteImplementorB.OpertionImp


            大中小号毛笔 沾七彩颜料-----
            -----0：LarghBrush & Red
            -----1：LarghBrush & Orange
            -----2：LarghBrush & Yellow
            -----3：LarghBrush & Green
            -----4：LarghBrush & Blue
            -----5：LarghBrush & Indigo
            -----6：LarghBrush & Purple
            -----7：MiddleBrush & Red
            -----8：MiddleBrush & Orange
            -----9：MiddleBrush & Yellow
            -----10：MiddleBrush & Green
            -----11：MiddleBrush & Blue
            -----12：MiddleBrush & Indigo
            -----13：MiddleBrush & Purple
            -----14：SmallBrush & Red
            -----15：SmallBrush & Orange
            -----16：SmallBrush & Yellow
            -----17：SmallBrush & Green
            -----18：SmallBrush & Blue
            -----19：SmallBrush & Indigo
            -----20：SmallBrush & Purple
             */
        }
        public static void Run()
        {
            Console.WriteLine("类图直译场景-----");
            //Abstraction抽象分支扩展1/2，Implementor实现分支扩展A/B
            var list = new Abstraction[]
            {
                new RefinedAbstraction1( new ConcreteImplementorA() ),
                new RefinedAbstraction1( new ConcreteImplementorB() ),
                new RefinedAbstraction2( new ConcreteImplementorA() ),
                new RefinedAbstraction2( new ConcreteImplementorB() ),
            };

            var i = 0;
            foreach(var t in list)
            {
                Console.Write("-----{0}：", i++);
                t.Operation();
            }
        }

        public static void Run2()
        {
            Console.WriteLine("\r\n\r\n大中小号毛笔 沾七彩颜料-----");
            var list = new Abstraction[]
            {
                new LarghBrush( new Red() ),
                new LarghBrush( new Orange() ),
                new LarghBrush( new Yellow() ),
                new LarghBrush( new Green() ),
                new LarghBrush( new Blue() ),
                new LarghBrush( new Indigo() ),
                new LarghBrush( new Purple() ),

                new MiddleBrush( new Red() ),
                new MiddleBrush( new Orange() ),
                new MiddleBrush( new Yellow() ),
                new MiddleBrush( new Green() ),
                new MiddleBrush( new Blue() ),
                new MiddleBrush( new Indigo() ),
                new MiddleBrush( new Purple() ),

                new SmallBrush( new Red() ),
                new SmallBrush( new Orange() ),
                new SmallBrush( new Yellow() ),
                new SmallBrush( new Green() ),
                new SmallBrush( new Blue() ),
                new SmallBrush( new Indigo() ),
                new SmallBrush( new Purple() ),
            };

            var i = 0;
            foreach (var t in list)
            {
                Console.Write("-----{0}：", i++);
                t.Operation();
            }
        }

        public static void ShowConsoleColor()
        {
            Console.WriteLine("\r\n\r\n控制台颜色-----");
            for (var i = 0; i < 16; i++)
            {
                Console.ForegroundColor = (ConsoleColor)i;
                Console.WriteLine("{0}", Console.ForegroundColor);
            }
        }

        abstract class Abstraction
        {
            Implementor imp;

            public Abstraction(Implementor imp)
            {
                this.imp = imp;
            }

            public virtual void Operation()
            {
                Console.Write("{0} & ", this.GetType().Name);
                imp.OpertionImp();
            }
        }

        abstract class Implementor
        {
            public virtual void OpertionImp()
            {
                Console.WriteLine("{0}", this.GetType().Name);
            }
        }

        #region 类图直译场景
        class RefinedAbstraction1 : Abstraction
        {
            public RefinedAbstraction1(Implementor imp):
                base(imp)
            { }
            //RefinedOperation
            public override void Operation()
            {
                base.Operation();
            }
        }

        class RefinedAbstraction2 : Abstraction
        {
            public RefinedAbstraction2(Implementor imp) :
                base(imp)
            { }
            //RefinedOperation
            public override void Operation()
            {
                base.Operation();
            }
        }

        class ConcreteImplementorA : Implementor
        {
            public override void OpertionImp()
            {
                Console.WriteLine("ConcreteImplementorA.OpertionImp");
            }
        }

        class ConcreteImplementorB : Implementor
        {
            public override void OpertionImp()
            {
                Console.WriteLine("ConcreteImplementorB.OpertionImp");
            }
        }
        #endregion

        #region 伪现实场景：大中小号毛笔 沾七彩颜料
        class LarghBrush : Abstraction
        {
            public LarghBrush(Implementor imp) :base(imp)
            { }
        }

        class MiddleBrush : Abstraction
        {
            public MiddleBrush(Implementor imp) :base(imp)
            { }
        }

        class SmallBrush : Abstraction
        {
            public SmallBrush(Implementor imp) : base(imp)
            { }
        }


        abstract class MyImplementor: Implementor
        {
            public override void OpertionImp()
            {
                var lastColor = Console.ForegroundColor;
                Console.ForegroundColor = this.Color;
                base.OpertionImp();
                Console.ForegroundColor = lastColor;
            }
            public abstract ConsoleColor Color { get; }
        }

        class Red: MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Red; } }
        }
        class Orange : MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.DarkYellow; } }
        }
        class Yellow : MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Yellow; } }
        }
        class Green : MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Yellow; } }
        }
        class Blue : MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Blue; } }
        }
        class Indigo: MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Cyan; } }
        }
        class Purple : MyImplementor
        {
            public override ConsoleColor Color { get { return ConsoleColor.Magenta; } }
        }
        #endregion
    }
}
           

相关参考：

https://en.wikipedia.org/wiki/Bridge_pattern

https://www.cnblogs.com/forlina/archive/2011/06/22/2087350.html