装饰器模式

意图：动态的将责任附加到对象上
什么时候使用：
1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
2.处理那些可以撤销的职责
3.当不能采用生成子类的方式进行扩充时
结构图：

示例代码：

[java] view plain copy

 

1. 1 package com.test.patten.decorator;  
2. 2   
3. 3 public interface Person {  
4. 4     void doCoding();  
5. 5 }  
6. 复制代码  
7.  1 package com.test.patten.decorator;  
8.  2   
9.  3 public class Employee implements Person {  
10.  4   
11.  5     @Override  
12.  6     public void doCoding() {  
13.  7         System.out.println("程序员加班写程序啊，写程序，终于写完了。。。");  
14.  8     }  
15.  9   
16. 10 }  
17.   
18. 1 package com.test.patten.decorator;  
19. 2   
20. 3 public abstract class Manager implements Person{  
21. 4       
22. 5     //装饰器增加功能  
23. 6     public abstract void doCoding();  
24. 7   
25. 8 }  
26.   
27.  1 package com.test.patten.decorator;  
28.  2   
29.  3 public class ManagerA extends Manager {  
30.  4     private Person person;//给雇员升职  
31.  5       
32.  6     public ManagerA(Person person) {  
33.  7         super();  
34.  8         this.person = person;  
35.  9     }  
36. 10     @Override  
37. 11     public void doCoding() {  
38. 12         doEarlyWork();  
39. 13         person.doCoding();          
40. 14     }  
41. 15     /** 
42. 16      * 项目经理开始前期准备工作 
43. 17      */  
44. 18     public void doEarlyWork() {  
45. 19         System.out.println("项目经理A做需求分析");  
46. 20         System.out.println("项目经理A做架构设计");  
47. 21         System.out.println("项目经理A做详细设计");   
48. 22     }  
49. 23 }  
50.   
51.  1 package com.test.patten.decorator;  
52.  2   
53.  3 public class ManagerB extends Manager {  
54.  4     private Person person;//给雇员升职  
55.  5       
56.  6     public ManagerB(Person person) {  
57.  7         super();  
58.  8         this.person = person;  
59.  9     }  
60. 10     @Override  
61. 11     public void doCoding() {  
62. 12         person.doCoding();  
63. 13         doEndWork();  
64. 14     }  
65. 15     /** 
66. 16      * 项目经理开始项目收尾工作 
67. 17      */  
68. 18     public void doEndWork() {  
69. 19         System.out.println("项目经理B 在做收尾工作");  
70. 20     }  
71. 21       
72. 22 }  
73.   
74.   
75.  1 package com.test.patten.decorator;  
76.  2   
77.  3 public class Client {  
78.  4     public static void main(String args[]){  
79.  5         Person employee = new Employee();  
80.  6         employee = new ManagerA(employee);//赋予程序猿项目经理A职责  
81.  7         employee = new ManagerB(employee);//赋予程序猿项目经理B职责  
82.  8           
83.  9         employee.doCoding();  
84. 10     }  
85. 11 }  

项目经理A做需求分析

项目经理A做架构设计

项目经理A做详细设计

程序员加班写程序啊，写程序，终于写完了。。。

项目经理B 在做收尾工作

 实际应用中的例子：Java i/o

应用到的设计原则：对扩展开放，对修改关闭

优缺点：

1.装饰者类反应出被装饰的组件类型

2.装饰者类可以在被装饰者的行为前面或后面加上自己的行为，甚至取代被装饰者的行为，达到特定的目的

3.可以用无数个装饰者包装一个组件，装饰者类会导致设计中出现许多小对象，过度使用会让程序变的复杂

4.装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型