装饰者模式一染色馒头

一模式定义

        装饰者模式，是在不改变原类文件和使用继承的情况下，动态扩展一个对象功能，它是通过创建一个包装对象，也就是装饰来包装真实的对象。

• 装饰对象和真实对象有相同接口，这样客户端对象就可以和真实对象相同方式和装饰对象交互。
• 装饰对象包含一个真实对象的引用。

二模式举例

1模式分析

我们借用黑心商贩制做染色馒头案例说明这一模式。

2装饰者模式静态类图

3代码示例

3.1创建馒头接口——IBread

Java代码  

1. package com.demo.abs;  
2.   
3. /** 
4.  * 馒头加工接口 
5.  *  
6.  * @author 
7.  *  
8.  */  
9. public interface IBread {  
10.     // 准备材料  
11.     public void prepair();  
12.   
13.     // 和面  
14.     public void kneadFlour();  
15.   
16.     // 蒸馒头  
17.     public void steamed();  
18.   
19.     /** 
20.      * 加工馒头方法 
21.      */  
22.     public void process();  
23. }  

3.2正常馒头实现——NormalBread

Java代码  

1. package com.demo.abs;  
2.   
3. /** 
4.  * 正常馒头的实现 
5.  *  
6.  * @author 
7.  *  
8.  */  
9. public class NormalBread implements IBread {  
10.     // 准备材料  
11.     public void prepair() {  
12.         System.out.println("准备面粉、水以及发酵粉...");  
13.     }  
14.   
15.     // 和面  
16.     public void kneadFlour() {  
17.         System.out.println("和面...");  
18.     }  
19.   
20.     // 蒸馒头  
21.     public void steamed() {  
22.         System.out.println("蒸馒头...香喷喷的馒头出炉了！");  
23.     }  
24.   
25.     /** 
26.      * 加工馒头方法 
27.      */  
28.     public void process() {  
29.         // 准备材料  
30.         prepair();  
31.         // 和面  
32.         kneadFlour();  
33.         // 蒸馒头  
34.         steamed();  
35.     }  
36.   
37. }  

3.3创建抽象装饰者——AbstractBread

Java代码  

1. package com.demo.decorator;  
2.   
3. import com.demo.abs.IBread;  
4.   
5. /** 
6.  * 抽象装饰者 
7.  *  
8.  * @author 
9.  *  
10.  */  
11. public abstract class AbstractBread implements IBread {  
12.     // 存储传入的IBread对象  
13.     private final IBread bread;  
14.   
15.     public AbstractBread(IBread bread) {  
16.         this.bread = bread;  
17.     }  
18.   
19.     // 准备材料  
20.     public void prepair() {  
21.         this.bread.prepair();  
22.     }  
23.   
24.     // 和面  
25.     public void kneadFlour() {  
26.         this.bread.kneadFlour();  
27.     }  
28.   
29.     // 蒸馒头  
30.     public void steamed() {  
31.         this.bread.steamed();  
32.     }  
33.   
34.     // 加工馒头方法  
35.     public void process() {  
36.         prepair();  
37.         kneadFlour();  
38.         steamed();  
39.   
40.     }  
41. }  

3.4创建染色剂装饰者——CornDecorator

Java代码  

1. package com.demo.decorator;  
2.   
3. import com.demo.abs.IBread;  
4.   
5. /** 
6.  * 染色的玉米馒头 
7.  *  
8.  * @author 
9.  *  
10.  */  
11. public class CornDecorator extends AbstractBread {  
12.   
13.     // 构造方法  
14.     public CornDecorator(IBread bread) {  
15.         super(bread);  
16.     }  
17.   
18.     // 黑心商贩 开始染色了  
19.     public void paint() {  
20.         System.out.println("添加柠檬黄的着色剂...");  
21.     }  
22.   
23.     // 重载父类的和面方法  
24.     @Override  
25.     public void kneadFlour() {  
26.         // 在面粉中加入 染色剂 之后才开始和面  
27.         this.paint();  
28.         // 和面  
29.         super.kneadFlour();  
30.     }  
31. }  

3.5创建甜蜜素装饰者——SweetDecorator

Java代码  

1. package com.demo.decorator;  
2.   
3. import com.demo.abs.IBread;  
4.   
5. /** 
6.  * 甜蜜素馒头 
7.  *  
8.  * @author 
9.  *  
10.  */  
11. public class SweetDecorator extends AbstractBread {  
12.     // 构造方法  
13.     public SweetDecorator(IBread bread) {  
14.         super(bread);  
15.     }  
16.   
17.     // 黑心商贩 开始添加甜蜜素  
18.     public void paint() {  
19.         System.out.println("添加甜蜜素...");  
20.     }  
21.   
22.     // 重载父类的和面方法  
23.     @Override  
24.     public void kneadFlour() {  
25.         // 在面粉中加入 甜蜜素 之后才开始和面  
26.         this.paint();  
27.         // 和面  
28.         super.kneadFlour();  
29.     }  
30. }  

3.6生产甜玉米馒头——Client

Java代码  

1. package com.demo;  
2.   
3. import com.demo.abs.IBread;  
4. import com.demo.abs.NormalBread;  
5. import com.demo.decorator.CornDecorator;  
6. import com.demo.decorator.SweetDecorator;  
7.   
8. /** 
9.  * 客户端应用程序 
10.  *  
11.  * @author 
12.  *  
13.  */  
14. public class Client {  
15.   
16.     /** 
17.      * @param args 
18.      */  
19.     public static void main(String[] args) {  
20.         // 生产装饰馒头  
21.         System.out.println("\n====开始装饰馒头！！！");  
22.         // 创建普通的正常馒头实例  
23.         // 这是我们需要包装（装饰）的对象实例  
24.         IBread normalBread = new NormalBread();  
25.   
26.         // 下面就开始 对正常馒头进行装饰了！！！  
27.         // 使用甜蜜素装饰馒头  
28.         normalBread = new SweetDecorator(normalBread);  
29.         // 使用柠檬黄的着色剂装饰馒头  
30.         normalBread = new CornDecorator(normalBread);  
31.         // 生产馒头信息  
32.         normalBread.process();  
33.         System.out.println("====装饰馒头结束！！！");  
34.   
35.     }  
36.   
37. }  

4运行结果

====开始装饰馒头！！！

准备面粉、水以及发酵粉...

添加柠檬黄的着色剂...

添加甜蜜素...

和面...

蒸馒头...香喷喷的馒头出炉了！

====装饰馒头结束！！！

 

三该模式设计原则

1 封闭变化部分

2 “开一闭"原则

3 面向抽象编程

4 优先使用组合，而非继承

 

四使用场合

1当我们需要为某个现有对象动态增加一个新功能或职责时，可以考虑使用装饰者模式。

2当某个对象的职责经常发生变化或经常需要动态增加职责，避免为了适应这样的变化而增加继承子类扩展的方式，因为这种方式会造成子类膨胀速度过快，难以控制，此时可以使用装饰者模式。

 

五装饰者模式静态类图