设计模式学习笔记(三)：装饰者模式

一.概念

     动态的给一个对象添加额外的职责。想要扩展功能的话，装饰者提供了一种有别于继承的另外一种选择。

 

二.UML

1. Component(概念中提到的对象接口)，也就是“被装饰者”。
2. ConcreateComponent(未添加任何职责的，对象接口的子类)。
3. Decorator(装饰者抽象类)，扩张了对象接口的功能。
4. ConcreteDrcorator(具体装饰类)，具体怎么装饰对象接口的在这些类里面反映。

三.实例分析

    家里买了一套房子，需要装修，考虑到预算只有这么多，不能采用全包的方式，于是采用将装修工作细化，以节省开销。

     House

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 被装修者-房子 
5.  * @author eason 
6.  * 
7.  */  
8. public interface House {  
9.     public void decorate();  
10. }  

 

     BlankHouse

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 未经装修的房子 
5.  * @author eason 
6.  * 
7.  */  
8. public class BlankHouse implements House{  
9.   
10.     @Override  
11.     public void decorate() {  
12.         System.out.println("未经装修的房子");  
13.     }  
14.   
15. }  

 

     Decorator

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 装修工抽象类 
5.  * @author eason 
6.  * 
7.  */  
8. public class Decorator implements House{  
9.       
10.     private House house;  
11.       
12.     public Decorator(House house) {  
13.         this.house = house;  
14.     }  
15.   
16.     @Override  
17.     public void decorate() {  
18.         house.decorate();  
19.     }  
20.   
21. }  

 

     ElectricWirer

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 电线工 
5.  * @author eason 
6.  * 
7.  */  
8. public class ElectricWirer extends Decorator {  
9.       
10.     public ElectricWirer(House house) {  
11.         super(house);  
12.     }  
13.   
14.     @Override  
15.     public void decorate() {  
16.         super.decorate();  
17.         //自己的逻辑-具体怎么包装的写在super.decorate()的前后任何地方  
18.         System.out.println("已经装修完电线");  
19.     }  
20. }  

 

 

     Floorer

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 地板工 
5.  * @author eason 
6.  * 
7.  */  
8. public class Floorer extends Decorator {  
9.       
10.     public Floorer(House house) {  
11.         super(house);  
12.     }  
13.   
14.     @Override  
15.     public void decorate() {  
16.         super.decorate();  
17.         //自己的逻辑-具体怎么包装的写在super.decorate()的前后任何地方  
18.         System.out.println("已经装修完地板");  
19.     }  
20. }  

 

 

     WaterPiper

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 水管工 
5.  * @author eason 
6.  * 
7.  */  
8. public class WaterPiper extends Decorator {  
9.       
10.     public WaterPiper(House house) {  
11.         super(house);  
12.     }  
13.   
14.     @Override  
15.     public void decorate() {  
16.         super.decorate();  
17.         //自己的逻辑-具体怎么包装的写在super.decorate()的前后任何地方  
18.         System.out.println("已经装修完水管");  
19.     }  
20. }  

 

 

     TestDecorator

Java代码  

1. package com.zzy.decorator;  
2.   
3. /** 
4.  * 测试类 
5.  * @author eason 
6.  * 
7.  */  
8. public class TestDecorator {  
9.   
10.     public static void main(String[] args) {  
11.         //空白房子一个  
12.         House house = new BlankHouse();  
13.         //一层层装修  
14.         Decorator dec = new Floorer(new ElectricWirer(new WaterPiper(house)));  
15.         dec.decorate();  
16.     }  
17.   
18. }  

 

四.使用场景

1. 为已有组件动态添加更多功能。

五.使用感受

1. 将装饰功能的代码从Component里面提了出来，简化了Component。
2. 客户端可以在运行时根据需要，选择需要的功能来包装Component。
3. 继承是扩展功能的方式之一，但并不见得是达到弹性设计的最佳形方式。
4. 组合和委托可用于在运行时动态地加上新的行为。装饰者模式实际上就是组合和委托。再次提到组合和委托，第一次提到是在策略模式 里面。
   
5. 在日常的设计中，应该允许行为被扩展，而不需修改现有的代码。
6. 装修者会导致设计中出现许多小对象，如果过度使用，会让程序变的复杂。