设计模式之装饰模式

        装饰者模式,就是动态的给一个对象添加一些职责,他比生成子类更为灵活。这个模式是非常重要的,在我们设计完系统之后,一定还会进行修改,给他添加功能,这时候装饰者模式的好处就不言而喻了。

        装饰者模式的工作原理是,创建一个初始对象,然后一步一步的给他添加功能,或者属性。

        举个例子:假如初始对象是一个空办公室为装饰对象,通过装饰者1,成为一个有两张办公桌的办公室,这样有两张办公桌的办公室就变成了新的装饰对象。然后这个对象在通过装饰者2 ,变成有电脑的,有办公桌的办公室。这样有电脑的,有办公桌的办公室就变成了新的装饰对象。然后一步一步的去装饰最后变成一个具体的对象,如图所示,像一个链表一样:

     

       现在看一下类图:

       

        下面举一个具体的例子,有一个办公室,里边原来是空的,现在要放的桌子,过几天有要求又要放一个电脑,然后过了一段时间, 又要求放一个花盆。根据开闭原则不能修改,只能增加,所以想到用装饰者模式。

         看一下具体的类图,然后对比一下上边给的抽象话的类图,有助于你更好地理解抽象模式:

         

        下边看一下代码:

[csharp] view plain copy
print ?
  1.  //抽象办公室  
  2.     abstract  class Bangongshi  
  3.     {  
  4.         public abstract void Show();   
  5.     }  
  6.   
  7.     //具体办公室  
  8.     class Jutibangongshi:Bangongshi  
  9.     {  
  10.         public Jutibangongshi()  
  11.         { }  
  12.         public string name;  
  13.         public Jutibangongshi(string name)  
  14.         {  
  15.             this.name = name;  
  16.         }  
  17.   
  18.         public override void Show()  
  19.         {  
  20.             Console.WriteLine(”装饰的{0}”, name);  
  21.               
  22.         }  
  23.     }  
  24.   
  25.     //办公室装饰  
  26.     class Zhuangshi : Bangongshi  
  27.     {  
  28.         protected Bangongshi bangongshi;  
  29.         public void SetBangongshi(Bangongshi bangongshi)  
  30.         {  
  31.             this.bangongshi = bangongshi;  
  32.         }  
  33.         public override void Show()  
  34.         {  
  35.             if (bangongshi != null)  
  36.             {  
  37.                 bangongshi.Show();  
  38.             }  
  39.         }  
  40.     }  
  41.   
  42.     //桌子  
  43.     class Zhuozi : Zhuangshi  
  44.     {  
  45.         private string addThing;  
  46.         public override void Show()  
  47.         {  
  48.             addThing = ”桌子”;  
  49.             Console.Write(addThing);  
  50.             base.Show();  
  51.         }  
  52.     }  
  53.   
  54.     //电脑  
  55.     class Diannao : Zhuangshi  
  56.     {  
  57.         private string addThing;  
  58.         public override void Show()  
  59.         {  
  60.             addThing = ”电脑”;  
  61.             Console.Write(addThing);  
  62.             base.Show();  
  63.         }  
  64.    
  65.     }  
  66.   
  67.     //花盆  
  68.     class Huapen : Zhuangshi  
  69.     {  
  70.         private string addThing;  
  71.         public override void  Show()  
  72.         {  
  73.             addThing = ”花盆”;  
  74.             Console.Write(addThing);  
  75.              base.Show();  
  76.         }  
  77. <span style=”font-size:18px;”>    }</span>  
 //抽象办公室
    abstract  class Bangongshi
    {
        public abstract void Show(); 
    }

    //具体办公室
    class Jutibangongshi:Bangongshi
    {
        public Jutibangongshi()
        { }
        public string name;
        public Jutibangongshi(string name)
        {
            this.name = name;
        }

        public override void Show()
        {
            Console.WriteLine("装饰的{0}", name);

        }
    }

    //办公室装饰
    class Zhuangshi : Bangongshi
    {
        protected Bangongshi bangongshi;
        public void SetBangongshi(Bangongshi bangongshi)
        {
            this.bangongshi = bangongshi;
        }
        public override void Show()
        {
            if (bangongshi != null)
            {
                bangongshi.Show();
            }
        }
    }

    //桌子
    class Zhuozi : Zhuangshi
    {
        private string addThing;
        public override void Show()
        {
            addThing = "桌子";
            Console.Write(addThing);
            base.Show();
        }
    }

    //电脑
    class Diannao : Zhuangshi
    {
        private string addThing;
        public override void Show()
        {
            addThing = "电脑";
            Console.Write(addThing);
            base.Show();
        }

    }

    //花盆
    class Huapen : Zhuangshi
    {
        private string addThing;
        public override void  Show()
        {
            addThing = "花盆";
            Console.Write(addThing);
             base.Show();
        }
    }
      客户端代码:

[csharp] view plain copy
print ?
  1. //客户端  
  2. static void Main(string[] args)  
  3.     {  
  4.         Jutibangongshi office = new Jutibangongshi(“办公室”);  
  5.   
  6.         Zhuozi desk = new Zhuozi();  
  7.         Diannao computer = new Diannao();  
  8.         Huapen glass = new Huapen();  
  9.   
  10.         desk.SetBangongshi(office);  
  11.         computer.SetBangongshi(desk);  
  12.         glass.SetBangongshi(computer);  
  13.   
  14.         glass.Show();  
  15.        }  
 //客户端
 static void Main(string[] args)
     {
         Jutibangongshi office = new Jutibangongshi("办公室");

         Zhuozi desk = new Zhuozi();
         Diannao computer = new Diannao();
         Huapen glass = new Huapen();

         desk.SetBangongshi(office);
         computer.SetBangongshi(desk);
         glass.SetBangongshi(computer);

         glass.Show();
        }
看一下结果:


        其实,装饰者模式呢,它把类中的一些装饰功能移除,再将这些装饰功能写到另外的类中,这样可以简化核心类的复杂度,同时,面对不同的需求时,可以提供代码得复用。

        装饰器模式允许我们在实现中提供扩展点。你可能注意到,在实现装饰者时,我从来没有涉及到Component类。因此,即使它并不拥有类,一样能通过动态添加行为类装饰它,甚至是递归的方式。这些额外的行为可能在几处行为之前或之后添加,或者这种行为可能被阻止。装饰者能在类中提供新方法,甚至新属性。

       当然在使用装饰者模式的时候,也一定要慎重,不要感觉差不多,就用装饰模式。所有事情都点到为止。好了,今天就写到这里,以后还会继续更新设计模式博客,请你继续关注。欢迎您能够提出宝贵意见。谢谢




  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值