zoukankan      html  css  js  c++  java
  • 设计模式之桥模式

    参考博文: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();  
        }  
  • 相关阅读:
    hdu 6702 ^&^ 位运算
    hdu 6709 Fishing Master 贪心
    hdu 6704 K-th occurrence 二分 ST表 后缀数组 主席树
    hdu 1423 Greatest Common Increasing Subsequence 最长公共上升子序列 LCIS
    hdu 5909 Tree Cutting FWT
    luogu P1588 丢失的牛 宽搜
    luogu P1003 铺地毯
    luogu P1104 生日
    luogu P1094 纪念品分组
    luogu P1093 奖学金
  • 原文地址:https://www.cnblogs.com/youzoulalala/p/11047778.html
Copyright © 2011-2022 走看看