首页 > 代码库 > 设计模式 之 装饰者

设计模式 之 装饰者

2024-07-16 20:43:32   230人阅读

装饰模式（Deocrator）
          动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。




        所谓装饰，就是一些对象给主题对象做陪衬。我们可以想象，在一个公司里面，每个人都有一个办工作，办工作都需要有电脑、电话、文件夹、盆栽、签字笔、公章等作为装饰。但是不同的人的办公桌上的装饰肯定不一样。比如说，老总的办公桌上应该什么都有，但是一般工作人员的办公桌上，就不应该有电话和公章。我们怎么动态的来装饰办公桌呢？

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6.   
  7. namespace 装饰  
  8. {  
  9.     class Program  
  10.     {  
  11.         //办公桌  
  12.         public class officeDesk  
  13.         {  
  14.             public officeDesk()  
  15.             { }  
  16.             private string userName;  
  17.             public officeDesk(string userName)  
  18.             {  
  19.                 this.userName = userName;  
  20.             }  
  21.             public virtual void show()  
  22.             {  
  23.                 Console.WriteLine("{0}的办公桌：",userName );  
  24.             }  
  25.         }  
  26.         //装饰者  
  27.         public class Decorator : officeDesk  
  28.         {  
  29.             //需要知道装饰对象，对应UML中的聚合  
  30.             protected officeDesk desk;  
  31.             //装扮办公桌  
  32.             public void setDecortate(officeDesk desk)  
  33.             {  
  34.                 this.desk = desk;  
  35.             }  
  36.   
  37.             public override void show()  
  38.             {  
  39.                 if (desk!=null)  
  40.                 {  
  41.                     desk.show();  
  42.                 }  
  43.             }  
  44.   
  45.         }  
  46.   
  47.         //具体装饰类  
  48.         //电脑  
  49.         public class computer:Decorator  
  50.         {  
  51.             public override void show()  
  52.             {  
  53.                 base.show();  
  54.                 Console.WriteLine("一台电脑 ");  
  55.             }  
  56.         }  
  57.         //电话  
  58.         public class telephone : Decorator  
  59.         {  
  60.             public override void show()  
  61.             {  
  62.                 base.show();  
  63.                 Console.WriteLine("一部电话 ");  
  64.             }  
  65.         }  
  66.         //文件夹  
  67.         public class file : Decorator  
  68.         {  
  69.             public override void show()  
  70.             {  
  71.                 base.show();  
  72.                 Console.WriteLine("一个文件夹 ");  
  73.             }  
  74.         }  
  75.         //盆栽  
  76.         public class plant : Decorator  
  77.         {  
  78.             public override void show()  
  79.             {  
  80.                 base.show();  
  81.                 Console.WriteLine("一盆盆栽 ");  
  82.             }  
  83.         }  
  84.         //签字笔  
  85.         public class pen : Decorator  
  86.         {  
  87.             public override void show()  
  88.             {  
  89.                 base.show();  
  90.                 Console.WriteLine("一支签字笔 ");  
  91.             }  
  92.         }  
  93.         //公章  
  94.         public class seal : Decorator  
  95.         {  
  96.             public override void show()  
  97.             {  
  98.                 base.show();  
  99.                 Console.WriteLine("一个公章 ");  
  100.             }  
  101.         }  
  102.   
  103.   
  104.         static void Main(string[] args)  
  105.         {  
  106.             officeDesk renZong = new officeDesk("任总");  
  107.   
  108.             computer computer = new computer();  
  109.             telephone telephone = new telephone();  
  110.             file file = new file();  
  111.             plant plant = new plant();  
  112.             pen pen = new pen();  
  113.             seal seal = new seal();  
  114.   
  115.             computer.setDecortate(renZong);  
  116.             telephone.setDecortate(computer);  
  117.             file.setDecortate(telephone);  
  118.             plant.setDecortate(file);  
  119.             pen.setDecortate(plant );  
  120.             seal.setDecortate(pen);  
  121.             seal.show();  
  122.   
  123.             Console.WriteLine();  
  124.             officeDesk xiaoLi = new officeDesk("小李");  
  125.   
  126.             computer.setDecortate(xiaoLi);  
  127.             file.setDecortate(computer);  
  128.             pen.setDecortate(file );  
  129.             pen.show();  
  130.   
  131.             Console.Read();  
  132.         }  
  133.     }  
  134. }  






装饰者类图：

                                                 



在装饰模式结构图中包含如下几个角色：
       Component（抽象构件）：它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。
       ConcreteComponent（具体构件）：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。
       Decorator（抽象装饰类）：它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。
       ConcreteDecorator（具体装饰类）：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。




主要优点：
       1.对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。
       2.可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的具体装饰类，从而实现不同的行为。
       3.可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。
       4.具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合“开闭原则”。


主要缺点：
       1.使用装饰模式进行系统设计时将产生很多小对象。
       2. 装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。


适用场景：
       1.当我们需要为某个现有的对象动态地增加一个新的功能或职责时，可以考虑使用装饰者。
       2. 当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。


与适配器、策略的区别：

       装饰者是在不改变原内容的基础上，动态地增加新的行为；

       适配器则主要用来填补两个接口之间的差异，将一个接口转化为另一个接口；

       策略是以切换运算法则的方式变换功能。

 


联系
我们