设计模式之桥模式

参考博文：https://www.cnblogs.com/NewWork/archive/2013/06/03/3260597.html

本文只为了便于自身学习，如有侵权立删。

桥模式 （Bridge）

什么是桥模式：   分离接口或类的抽象部分（稳定）和实现部分（变化、多种实现），然后通过桥连接（组合的方式，桥是Abstraction指向Implementor的引用）。

　　　　　　　　抽象和实现是两个不同维度的概念，分离这两个维度的变化以降低耦合度。

　　　　　　　　例如，抽象有3种变化，实现有4中变化，抽象和实现同在一个抽象类（或接口）中，通过继承则需要3*4=12个类。但是分离不同维度部分，通过组合的方法则只需要3+4种类。

　　　　　　　　在下面的代码中，抽象部分：operation()；实现部分：Implementor

桥模式的基本类图：

桥接模式的参与者包括：

         抽象（Abstraction），其定义了类的接口；

         精化抽象（Refined Abstraction），其扩展和实现接口；

         实现者（Implementer），其定义实现类的接口；

        具体实现者（ConcreteImplementor），其为实现类。

　　 桥（bridge），指向Implementer的抽象引用。

　　抽象通过多态的机制封装实现的变化，通过指向Implementer的抽象引用调用不同的实现（类似策略模式）。

桥模式基本代码（C#代码）：

抽象（Abstraction）

    public abstract class Abstraction  
    {                                
        protected Implementor _implementor;   //其实这只是一种保护措施。。。  
                                              //是维护着抽象类和实现类的一种联系。。。抽象部分和实现部分还是存在内部联系  
                                              // 抽象部分的实现通常是需要调用实现部分的功能来实现   
      
        public Implementor MyImplementor  
        {  
            get {return _implementor;}  
            set { _implementor = value; }  
        }  
      
        public virtual void Operation()                //抽象类的实现方式，也是很抽象的，其实就是对外提供的一种借口。  
        {                                              //我们看到它具体的实现也是调用到实现类的具体实现的方法的。  
            _implementor.OperationImp();  
        }  
      
    }  
      
    //具体实现类RefinedAbstraction  
      
    public class RefinedAbstraction : Abstraction  
    {  
        public override void Operation()  
        {  
            _implementor.OperationImp();               //具体实现类，被提炼的抽象。  
        }  
    }  

实现者（Implementer）

    public abstract class Implementor  
    {  
        public abstract void OperationImp();  
    }  
      
    //具体的实现。  
    public class ConcreteImplementorA:Implementor  
    {  
        public override void OperationImp()  
        {  
            Console.WriteLine("{0} 操作方法！", this.GetType().Name);  
        }  
    }  
      
    public class ConcreteImplementorB : Implementor  
    {  
        public override void OperationImp()  
        {  
            Console.WriteLine("{0} 操作方法！",this.GetType().Name);  
        }  
    }  

测试代码

    static void Main(string[] args)  
    {  
      
        //这里的主函数，类似的客户端的调用就很简单了。。。  
      
        Abstraction a1 = new RefinedAbstraction();         //可以被申明为子类的类型。具体实现类，被提炼的抽象。  
        //就像是我用客户端的方式去调用的时抽象类。  
      
        //对具体实现的一种调用。。。  
      
        //首先是对A实现的调用。。。  
        a1.MyImplementor = new ConcreteImplementorA();     //申明具体的实现方式。  
        a1.Operation();  
      
        //然后是对B具体实现的调用。。。  
      
        a1.MyImplementor = new ConcreteImplementorB();  
        a1.Operation();  
      
      
        //  
        Console.ReadKey();  
    }