设计模式-----装饰模式

装饰模式

Decorator，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
装饰模式的组成
1、抽象构件角色（Component）：定义了一个抽象接口，以规范准备接收附加责任的对象。
2、具体构件角色（Concrete Component）:这是被装饰者，定义一个将要被装饰增加功能的类。
3、装饰角色（Decorator）：持有一个构件对象的实例，并定义了抽象构件定义的接口。
4、具体装饰角色（Concrete Decorator）：负责给构件添加的功能。

装饰模式的类图



实例:大话设计模式中小菜见娇娇前对衣服的搭配

class Person
    {
        public Person ()
    {}
        private string name;
        public Person(string name)
        {
            this.name = name;
        }
       
        public virtual  void Show()
        {
            Console.WriteLine("装扮的{0}",name);
        }
      }

    class Finery : Person
    {
        protected Person component;
        //打扮
        public void Decorate(Person component)
        {
            this.component = component;
        }
        public override void Show()
        {
            if (component != null) 
            {
                component.Show();
            }
        }

    }
    class TShirts:Finery 
    {
        public override void Show()
          {
 	           Console .Write ("大T恤");
               base.Show();
           }
    }
    class BigTrouser:Finery 
    {
        public override void Show()
          {
 	           Console .Write ("垮裤");
               base.Show();
           }
    }
    class WearSneakers:Finery 
    {
        public override void Show()
             {
 	            Console .Write ("破球鞋");
                base.Show();
              }
    }
    class WearSuit:Finery 
    {
        public override void Show()
        {
 	        Console .Write ("西装");
            base.Show();
        }
    }
    class WearTie:Finery 
    {
        public override void Show()
        {
 	        Console .Write ("领带");
            base.Show();
        }
    }
    class WearLeatheShoes:Finery 
    {
        public override void Show()
        {
 	        Console .Write ("皮鞋");
            base.Show();
        }
    }
  }

主程序代码

static void Main(string[] args)
        {
            Person xc = new Person("小菜");
            Console.WriteLine("\n第一种装扮：");

            TShirts  dtx = new TShirts();
            BigTrouser  kk = new BigTrouser();
            WearSneakers  pqx = new WearSneakers();

            pqx.Decorate (xc);
            kk.Decorate (pqx);
            dtx.Decorate (kk);
            dtx.Show ();

           

            Console.WriteLine("\n第二种装扮：");
            WearSuit  xz = new WearSuit();
            WearTie  ld = new WearTie();
            WearLeatheShoes  px = new WearLeatheShoes();

             px.Decorate (xc);
            ld.Decorate(px );
            xz.Decorate (ld );
            
            xz.Show();
           
            Console.WriteLine("\n第三种装扮：");
            WearSneakers pqx2 = new WearSneakers();
            WearLeatheShoes px2 = new WearLeatheShoes();
            BigTrouser kk2 = new BigTrouser();
            WearTie ld2 = new WearTie();

            pqx2.Decorate(xc);
            px2.Decorate(pqx);
            kk2.Decorate(px2);
            ld2.Decorate(kk2);
            ld2.Show();

            Console.Read ();
        }

类图如下



使用装饰者模式的时候需要注意一下几点内容：
（1）装饰对象和真实对象有相同的接口。这样客户端对象就可以以和真实对象相同的方式和装饰对象交互。
（2）装饰对象包含一个真实对象的引用。
（3）装饰对象接受所有的来自客户端的请求，它把这些请求转发给真实的对象。
（4）装饰对象可以在转发这些请求以前或以后增加一些附加功能。
这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。然而，装饰者模式，不需要子类可以在应用程序运行时，动态扩展功能，更加方便、灵活。
适用装饰者模式场合：
1．当我们需要为某个现有的对象，动态的增加一个新的功能或职责时，可以考虑使用装饰模式。
2．当某个对象的职责经常发生变化或者经常需要动态的增加职责，避免为了适应这样的变化，而增加继承子类扩展的方式，因为这种方式会 造成子类膨胀的速度过快，难以控制。