设计模式速查版 结构型(上)

结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
1）适配器模式（Adapter Pattern）
2）桥接模式（Bridge Pattern）
3）组合模式（Composite Pattern）
4）装饰者模式（Decorator Pattern）
5）外观模式（Facade Pattern）
6）享元模式（Flyweight Pattern）
7）代理模式（Proxy Pattern）

1.适配器模式

1)简介:

将一个类的接口转换成客户希望的另外一个接口.主要是用来解决原本的接口不兼容问题.或者用来统一接口命名.

2)结构图:

3)代码:

/// 目标类(客户端直接打交道的类) 
public class Target 
{ 
    /// <summary></summary> 
    public void Request() 
    { 
    } 
}

/// 适配器类 
public class Adapter : Target 
{ 
    /// <summary></summary> 
    private Adaptee _adaptee = new Adaptee(); 
    /// <summary></summary> 
    public void Request() 
    { 
        //实际调用Adaptee的方法,这就起到适配作用 
        _adaptee.SpecificRequest(); 
    } 
}

/// 需要适配的类 
public class Adaptee 
{ 
    /// <summary></summary> 
    public void SpecificRequest() 
    { 
    } 
}

class Program 
{ 
    static void Main(string[] args) 
    {

        Target taget = new Adapter(); 
        taget.Request();

        //TODO 
        Console.ReadLine(); 
    } 
} 

4)适用:

通常用于对一个已经存在的类的改造上.用适配器可以不用去改动原有类或原有类难以改动.这时候可以通过适配器去间接调用原有类的方法.从而使得外部看来统一了调用接口.

2.桥接模式

1)简介:

将抽象部分与它的实现部分分离,使他们都可以独立地变化.通常是实现系统具有多个角度分类,而且每个分类都有可能会发生变化,于是将变化抽象封装起来.

具体做法是1.通过一个抽象的桥类聚合另一个接口,接口方法的具体实现延迟到由子类实现. 2.让具体操作类去继承抽象桥类,具体操作由子类控制,这样具体操作也是基于接口的,隔离其具体实现 3.客户端只依赖抽象桥类,即只依赖于两个抽象,无需理会具体实现(这样即客户端只需要和抽象"桥"打交道,通过桥去连接'两岸'的具体实现)这样封装了'两岸'的变化,方便扩展

2)结构图:

3)代码:

   

/// 实现接口 
   public interface Implementor 
   { 
       /// <summary></summary> 
       void OperationImp(); 
   }

   /// 具体实现A 
   public class CImplementorA : Implementor 
   { 
       /// <summary></summary> 
       public void OperationImp() 
       { 
           Console.Write("具体实现A的方法"); 
       } 
   }

   /// 具体实现B 
   public class CImplementorB : Implementor 
   { 
       /// <summary></summary> 
       public void OperationImp() 
       { 
           Console.Write("具体实现B的方法"); 
       } 
   }

   /// 抽象桥(用来连接两个抽象,同时供客户端调用) 
   public abstract class AbstractBridge 
   { 
       /// <summary></summary> 
       protected Implementor _implementor; 
       /// <summary></summary> 
       public void SetImplementor(Implementor implementor) 
       { 
           this._implementor = implementor; 
       } 
       /// <summary></summary> 
       public virtual void Operation() 
       { 
           this._implementor.OperationImp(); 
       } 
   }

   /// 具体操作A 
   public class OperatorA : AbstractBridge 
   { 
       /// <summary></summary> 
       public override void Operation() 
       { 
           _implementor.OperationImp(); 
           //TODO其他具体逻辑A操作 
       } 
   }

   /// 具体操作B 
   public class OperatorB : AbstractBridge 
   { 
       /// <summary></summary> 
       public override void Operation() 
       { 
           _implementor.OperationImp(); 
           //TODO其他具体的逻辑B操作 
       } 
   }

   class Program 
   { 
       static void Main(string[] args) 
       { 
           AbstractBridge bridgeA = new OperatorA();

           AbstractBridge bridgeB = new OperatorB(); //若要扩展实现另外一种具体操作,只要新添加一个Operator类即可

           bridgeA.SetImplementor(new CImplementorA()); 
           bridgeA.Operation();

           bridgeA.SetImplementor(new CImplementorB()); 
           bridgeA.Operation();

           //TODO 
           Console.ReadLine(); 
       } 
   } 

4)适用:

适用于一个系统中几个操作对象都可能有多种实现,由隔离变化知道,将这几个对象都抽象出来.这样用户在操作时候,就只依赖于抽象.方便了扩展.

3.组合模式

1)简介:

将对象组合成树形结构以表示'部分-整体'的层次结构.组合模式可以让各对象之间以任意的方式组合起来.然后向用户提供一个统一的调用接口,用户处理对象时不用去理会处理的是单一对象(叶子)还是组合对象.

2)结构图:

3)代码:

/// 抽象组件 
public abstract class Component 
{ 
    /// <summary>添加组件</summary> 
    public abstract void Add(Component c);

    /// <summary>删除组件</summary> 
    public abstract void Remove(Component c);

    /// <summary>展示组件</summary> 
    public abstract void Display(Component c);

}

/// 叶子组件 
public class LeafComponent : Component 
{ 
    /// <summary></summary> 
    public override void Display(Component c) 
    { 
    } 
}

/// 枝干组件 
public class NodeComponent : Component 
{ 
    /// 聚合组件(可以是继承抽象部件的任何子组件,包括叶子组件和枝干组件.这样可以使得子组件任意组合[组合模式的意义在此]) 
    private List<Component> children = new List<Component>();

    /// <summary></summary> 
    public override void Add(Component c) 
    { 
        children.Add(c); 
    } 
    /// <summary></summary> 
    public override void Remove(Component c) 
    { 
        children.Remove(c); 
    } 
    /// <summary></summary> 
    public override void Display(Component c) 
    { 
        foreach (Component component in children) 
        { 
            //TODO.. 
  
        } 
    } 
}

class Program 
{ 
    static void Main(string[] args) 
    { 
        //根节点 
        Component root = new NodeComponent(); 
        root.Add(new LeafComponent()); 
        root.Add(new NodeComponent());

 

        //枝干节点 
        Component nodeComp = new NodeComponent(); 
        nodeComp.Add(new NodeComponent());

        root.Add(nodeComp);

 

        //TODO 
        Console.ReadLine(); 
    } 
} 

4)适用:

1.当需求中体现部分与整体的层次结构关系时 2.希望对象之间可以任意组合形成一个新的组合对象,而且用户感觉不到组合对象与单个对象的差别时,即可以对外界提供统一的调用接口.

4.装饰者模式

1)简介:

动态地给一个对象添加一些额外的职责.  具体做法就是继承被装饰的对象并将其聚合到装饰对象内部,然后再调用被装饰对象的方法,接着再调用额外的方法.这样便起到装饰的作用.

2)结构图:

3)代码:

/// 抽象被装饰类 
    public abstract class Decoratee 
    { 
        /// <summary></summary> 
        public abstract void Operation(); 
    }

    /// 具体被装饰类 
    public class DecorateeA : Decoratee 
    { 
        /// <summary></summary> 
        public override void Operation() 
        { 
            Console.Write("我是eeA..."); 
        } 
    }

    /// 抽象装饰类 
    public abstract class Decorator : Decoratee 
    { 
        /// <summary></summary> 
        protected Decoratee _decoratee; 
        /// <summary></summary> 
        public void SetDecoratee(Decoratee decoratee) 
        { 
            this._decoratee = decoratee; 
        } 
        /// <summary></summary> 
        public override void Operation() 
        { 
            _decoratee.Operation();

        } 
    }

    /// 具体装饰者类A 
    public class DecoratorA : Decorator 
    {

        /// <summary></summary> 
        public override void Operation() 
        { 
            //调用父类操作 
            base.Operation();

            //TODO其他操作 
            Console.Write("eeA,你不知道我在装饰你.嘿嘿..");

        } 
    }

    /// 具体装饰者类B 
    public class DecoratorB : Decorator 
    {

        /// <summary></summary> 
        public override void Operation() 
        { 
        } 
    }

    class Program 
    { 
        static void Main(string[] args) 
        { 
            DecorateeA ee = new DecorateeA(); 
            DecoratorA or = new DecoratorA();

            or.SetDecoratee(ee); 
            or.Operation();

       

            //TODO 
            Console.ReadLine(); 
        } 
    }

4)适用:

适用于想扩展原有类的功能,且不想改动原有类时.