用Delphi实现四人帮（Gof）设计模式-３装饰模式 Decorator MOdel收藏

装饰模式能够动态地给一个对象添加一些额外的职责,就扩展功能来说,装饰模式比生成子类更加灵活,采用了外挂的方式.参考下面类图中的说明文字,

掌握子类和装饰类的区别是掌握装饰模式的根本:

首先实现业务类TComponent和子类TConcreteComponent,放到BusinessComponents单元中

1. {**************************************************
2.          装饰模式(Decorator Model)              
3.   本单元包含一个业务对象父类和一个子类             
4.                                                   
5.   UnitOwner:coco.zhang                            
6.   Last Modified:2008-10-3                         
7. **************************************************}
8.  unit BusinessComponents;
9. 
   
10.  interface
11. 
    
12.  type 
13.    TComponent = class
14.      private 
15.      public 
16.        procedure  Operation;virtual;abstract;
17.    end;
18.   
19.    TConcreteComponent = class(TComponent)
20.      public 
21.        procedure Operation;override;
22.        procedure AddedOperation;
23.    end;
24. 
    
25. implementation
26. 
    
27.  procedure TConcreteComponent.Operation;
28.  begin
29.    Writeln(' TConcreteComponent.Operation'+ #10+#13 +'----这是父类规定的接口,子类进行了重写');
30.  end;
31. 
    
32.  procedure TConcreteComponent.AddedOperation;
33.  begin
34.    Writeln(' TConcreteComponent.AddedOperation'+ #10+#13 +'----这是子类新增的方法,和父类无关');
35.  end;
36. 
    
37. initialization
38. 
    
39. finalization
40. end.

测试业务类Decorator.dpr

1. program Decorator;
2. {$APPTYPE CONSOLE}
3. 
   
4. uses
5.   BusinessComponents in 'BusinessComponents.pas',
6.   SysUtils;
7. 
   
8. var 
9.   AComponent : TComponent;
10.   AConcreteComponent : TConcreteComponent;
11. begin
12.  
13.   {实例化业务对象,通过多态方式调用}
14.   AComponent := TConcreteComponent.Create;
15.   AComponent.Operation;
16.  {为了调用子类的个性化方法,类型转换}
17.   AConcreteComponent := TConcreteComponent(AComponent);
18.   AConcreteComponent.AddedOperation;
19. 
    
20. end.

执行结果:

D:\Projects\Delphi7\src\GofProjects\Decorator>Decorator
TConcreteComponent.Operation
----这是父类规定的接口,子类进行了重写
TConcreteComponent.AddedOperation
----这是子类新增的方法,和父类无关

编写包装类

1. {**************************************************}
2. {                                                 } 
3. {本单元包含一个装饰父类两个具体装饰子类           }
4. {                                                 }
5. { UnitOwner:coco.zhang                            }
6. { Last Modified:2008-10-2                         }
7. {**************************************************}
8. unit DecoratorUnit;
9. interface
10. uses
11.   BusinessComponents;
12. type
13. 
    
14.    {包装类基类}
15.    TComponentDecorator = class(TComponent)
16.      protected 
17.        BeDecoretedcomponent : TComponent;
18.      public
19.        constructor Create(ArgComponent : TComponent ); 
20.        procedure Operation;override;
21.    end;
22. 
    
23.    {包装类子类}
24.    TConcreteDecoratorA = class(TComponentDecorator)
25.      public
26.        procedure Operation;override;
27.        procedure DecoratedOperation;
28.    end;
29.     
30. implementation
31. 
    
32.  {实现包装类基类}
33.   constructor TComponentDecorator.Create(ArgComponent : TComponent );
34.   begin
35.     BeDecoretedcomponent := ArgComponent;
36.   end;
37. 
    
38.   procedure TComponentDecorator.Operation;
39.   begin
40.     if BeDecoretedcomponent <> nil then
41.       BeDecoretedcomponent.Operation;
42.     //Writeln('TComponentDecorator Operation方法');
43.   end;
44. 
    
45.  {实现包装类子类}
46.   procedure TConcreteDecoratorA.Operation;
47.   begin
48.     Writeln('TConcreteDecoratorA 对象中调用父类 Operation方法');
49.     inherited Operation;
50.        DecoratedOperation;
51.   end;
52. 
    
53.  procedure TConcreteDecoratorA.DecoratedOperation;
54.  begin
55.     Writeln('TConcreteDecoratorA 包装的功能');
56.  end;
57. 
    
58. //initialize
59. 
    
60. //finalize
61. 
    
62. end.

改写客户端

1. program Decorator;
2. {$APPTYPE CONSOLE}
3. 
   
4. uses
5.   BusinessComponents in 'BusinessComponents.pas',
6.   DecoratorUnit,
7.   SysUtils;
8. 
   
9. var 
10.   AComponent : TComponent;
11.   AConcreteComponent : TConcreteComponent;
12.   ADecorator:TConcreteDecoratorA;
13. begin
14.   
15.   {实例化业务对象,通过多态方式调用}
16.   AComponent := TConcreteComponent.Create;
17.  // AComponent.Operation;
18.  {为了调用子类的个性化方法,类型转换}
19.   AConcreteComponent := TConcreteComponent(AComponent);
20.   //AConcreteComponent.AddedOperation;
21. 
    
22.   ADecorator := TConcreteDecoratorA.Create(AConcreteComponent);
23.   ADecorator.Operation;
24. end.

所谓包装也可以理解为包装类的对象中维护了一个带包装的对象,两者之间是组合关系. 每个装饰对象只关心自己的功能,不需要关心如何被添加到对象链中的.

总之,包装模式提供了为已有功能动态地添加更多功能的一种方式,即不断地把被包装对象的Operation方法强大了,或者说TComponent对象的Operation被修饰了.

这些修饰往往是为了满足某种特殊情况, 不易在主类中全部罗列,而且我们可以提供多种包装方法,以满足特殊需求.

我们应当养成有效地把类的核心职责和装饰功能区分开来的能力和习惯