设计模式之八 --- 装饰模式(Decorator)

http://blog.csdn.net/cjjky/article/details/7478788

 

 

【1】基本概念

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

【2】简单分析

          我们先来看下该设计模式的UML结构图

上图是Decorator 模式的结构图,让我们可以进行更方便的描述:

Component是定义一个对象接口，可以给这些对象动态地添加职责。

ConcreteComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。

Decorator是装饰抽象类，继承了Component,从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator存在的。

ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能。

【3】如何用Java语音来实现该设计模式

假设情景：某人装扮自己形象，穿衣服，裤子，鞋子，戴帽子等来把自己给包装起来，需要把所需的功能按正确的顺序串联起来进行控制，我们应该如何设计才能做到呢？如下，先看下代码结构图：

3.1 先创建一个接口类：Component.java 

[html] view plain copy print ?

1. package com.andyidea.patterns.component;  
2.   
3. public interface Component {  
4.       
5.     void show();  
6.   
7. }  

package com.andyidea.patterns.component;

public interface Component {
	
	void show();

}

3.2 创建一个具体的 ConcreteComponent 来实现 Component 接口：Person.java

[html] view plain copy print ?

1. package com.andyidea.patterns.concretecomponent;  
2.   
3. import com.andyidea.patterns.component.Component;  
4.   
5. public class Person implements Component{  
6.       
7.     private String name;  
8.       
9.     public String getName() {  
10.         return name;  
11.     }  
12.   
13.     public void setName(String name) {  
14.         this.name = name;  
15.     }  
16.   
17.     public Person(String name){  
18.         this.name = name;  
19.     }  
20.   
21.     @Override  
22.     public void show() {  
23.         System.out.println("装扮的" + name);  
24.     }  
25.   
26. }  

package com.andyidea.patterns.concretecomponent;

import com.andyidea.patterns.component.Component;

public class Person implements Component{
	
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Person(String name){
		this.name = name;
	}

	@Override
	public void show() {
		System.out.println("装扮的" + name);
	}

}

3.3 创建装饰类 Decorator 实现 Component 接口

[html] view plain copy print ?

1. package com.andyidea.patterns.decorator;  
2.   
3. import com.andyidea.patterns.component.Component;  
4.   
5. public class Decorator implements Component{  
6.       
7.     private Component mComponent;  
8.       
9.     public void decoratorObj(Component component){  
10.         mComponent = component;  
11.     }  
12.   
13.     @Override  
14.     public void show() {  
15.           
16.         if(mComponent != null){  
17.             mComponent.show();  
18.         }  
19.     }  
20.   
21. }  

package com.andyidea.patterns.decorator;

import com.andyidea.patterns.component.Component;

public class Decorator implements Component{
	
	private Component mComponent;
	
	public void decoratorObj(Component component){
		mComponent = component;
	}

	@Override
	public void show() {
		
		if(mComponent != null){
			mComponent.show();
		}
	}

}

3.4 分别创建具体的装饰类：Jeans.java , Pelisse.java, Sandal.java ...等等，分别继承 Decorator.java 类：

[html] view plain copy print ?

1. package com.andyidea.patterns.concretedecorator;  
2.   
3. import com.andyidea.patterns.decorator.Decorator;  
4.   
5. /** 牛仔裤 */  
6. public class Jeans extends Decorator {  
7.   
8.     @Override  
9.     public void show(){  
10.         System.out.println("穿牛仔裤");  
11.         super.show();  
12.     }  
13.       
14. }  

package com.andyidea.patterns.concretedecorator;

import com.andyidea.patterns.decorator.Decorator;

/** 牛仔裤 */
public class Jeans extends Decorator {

	@Override
	public void show(){
		System.out.println("穿牛仔裤");
		super.show();
	}
	
}

其余类类似，在这里就省略了。

3.5 客户端测试类：

[html] view plain copy print ?

1. package com.andyidea.patterns;  
2.   
3. import com.andyidea.patterns.concretecomponent.Person;  
4. import com.andyidea.patterns.concretedecorator.Jeans;  
5. import com.andyidea.patterns.concretedecorator.Sandal;  
6. import com.andyidea.patterns.concretedecorator.TShirt;  
7.   
8. /**  
9.  * 装饰模式测试客户端  
10.  * @author Andy.Chen  
11.  *  
12.  */  
13. public class DecoratorClient {  
14.   
15.     public static void main(String[] args) {  
16.         System.out.println("Welcome to Andy.Chen Blog!" +"\n"   
17.                    +"Decorator Patterns." +"\n");  
18.           
19.         Person mPerson = new Person("Andy");  
20.           
21.         Sandal mSandal = new Sandal();  
22.         Jeans mJeans = new Jeans();  
23.         TShirt mShirt = new TShirt();  
24.           
25.         mShirt.decoratorObj(mPerson);  
26.         mJeans.decoratorObj(mShirt);  
27.         mSandal.decoratorObj(mJeans);  
28.         mSandal.show();  
29.           
30.     }  
31.       
32. }  

package com.andyidea.patterns;

import com.andyidea.patterns.concretecomponent.Person;
import com.andyidea.patterns.concretedecorator.Jeans;
import com.andyidea.patterns.concretedecorator.Sandal;
import com.andyidea.patterns.concretedecorator.TShirt;

/**
 * 装饰模式测试客户端
 * @author Andy.Chen
 *
 */
public class DecoratorClient {

	public static void main(String[] args) {
		System.out.println("Welcome to Andy.Chen Blog!" +"\n" 
		           +"Decorator Patterns." +"\n");
		
		Person mPerson = new Person("Andy");
		
		Sandal mSandal = new Sandal();
		Jeans mJeans = new Jeans();
		TShirt mShirt = new TShirt();
		
		mShirt.decoratorObj(mPerson);
		mJeans.decoratorObj(mShirt);
		mSandal.decoratorObj(mJeans);
		mSandal.show();
		
	}
	
}

【4】测试显示输出的结果如下：

[html] view plain copy print ?

1. Welcome to Andy.Chen Blog!  
2. Decorator Patterns.  
3.   
4. 穿凉鞋  
5. 穿牛仔裤  
6. 穿T-Shirt  
7. 装扮的Andy  

Welcome to Andy.Chen Blog!
Decorator Patterns.

穿凉鞋
穿牛仔裤
穿T-Shirt
装扮的Andy

【5】总结： Decorator模式有以下的优缺点：

1. 比静态继承更灵活 与对象的静态继承相比， Decorator 模式提供了更加灵活的向对象添加职责的方式，可以使用添加和分离的方法，用装饰在运行时刻增加和删除职责。使用继承机制增加职责需要创建一个新的子类，如果需要为原来所有的子类都添加功能的话，每个子类都需要重写，增加系统的复杂度，此外可以为一个特定的 Component 类提供多个 Decorator ，这种混合匹配是适用继承很难做到的。

2. 避免在层次结构高层的类有太多的特征， Decorator 模式提供了一种“即用即付”的方法来添加职责，他并不试图在一个复杂的可订制的类中支持所有可预见的特征，相反可以定义一个简单的类，并且用 Decorator 类给他逐渐的添加功能，可以从简单的部件组合出复杂的功能。

3. Decorator 与它的 Component 不一样 Decorator 是一个透明的包装，如果我们从对象标识的观点出发，一个被装饰了的组件与这个组件是有差别的，因此使用装饰时不应该以来对象标识。

4. 产生许多小对象，采用 Decorator 模式进行系统设计往往会产生许多看上去类似的小对象，这些对象仅仅在他们相互连接的方式上有所不同。

注：本文为Andy.Chen原创，欢迎大家转载，转载请大家注明出处，谢谢！