结构型模式--装饰模式（Decorator）

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下：

Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：

[java]  view plain copy

1. public interface Sourceable {  
2.     public void method();  
3. }  

[java]  view plain copy

1. public class Source implements Sourceable {  
2.   
3.     @Override  
4.     public void method() {  
5.         System.out.println("the original method!");  
6.     }  
7. }  

[java]  view plain copy

1. public class Decorator implements Sourceable {  
2.   
3.     private Sourceable source;  
4.       
5.     public Decorator(Sourceable source){  
6.         super();  
7.         this.source = source;  
8.     }  
9.     @Override  
10.     public void method() {  
11.         System.out.println("before decorator!");  
12.         source.method();  
13.         System.out.println("after decorator!");  
14.     }  
15. }  

测试类：

[java]  view plain copy

1. public class DecoratorTest {  
2.   
3.     public static void main(String[] args) {  
4.         Sourceable source = new Source();  
5.         Sourceable obj = new Decorator(source);  
6.         obj.method();  
7.     }  
8. }  

输出：

before decorator!
the original method!
after decorator!

装饰器模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错！

 

==================================================================
 另外一个例子：

/** * Test.java 
* Created on 2013-8-1 上午10:02:29 
*/

package my;

/** 
 * <p>Project: Test2</p> 
 * <p>Title: Test.java</p> 
 * <p>Description: </p> 
 * <p>Copyright (c) 2013 Wilmar Consultancy Services</p>
 * <p>All Rights Reserved.</p>
 * @author <a href="mailto:liyong@wcs-global.com">liyong</a>
 */

public class Test {

	public static void main(String[] args) {

		Teacher t1 = new SimpleTeacher();

		Teacher t2 = new CppTeacher(t1);

		Teacher t3 = new JavaTeacher(t2);

		t3.teach();

		// t.teach();

	}

}

abstract class Teacher {

	public abstract void teach();

}

class SimpleTeacher extends Teacher {

	public void teach() {

		System.out.println("Good Good Study, Day Day Up");

	}

}

class JavaTeacher extends Teacher {

	Teacher teacher;

	public JavaTeacher(Teacher t) {

		this.teacher = t;
	}

	public void teach() {

		teacher.teach();

		System.out.println("Teach Java");

	}

}

class CppTeacher extends Teacher {

	Teacher teacher;

	public CppTeacher(Teacher t) {

		this.teacher = t;

	}

	public void teach() {

		teacher.teach();

		System.out.println("Teach C++");

	}

}

 3、===============================================================

装饰模式：给一个类添加一些额外的职责，并且在添加这些额外的职责时不会控制该类的执行逻辑。 

UML类图： 
 

组成部分： 
抽象构件：原始的功能接口 
具体构件：具体的原始功能类 
装饰角色：持有具体构件类的对象，以便执行原有功能 
具体装饰：具体扩展的功能在这里 

下面看一个对开车功能拓展的实例（晚上+开车）： 
抽象构件： 

Java代码  

1. package com.gjy.drector;  
2.   
3. /** 
4.  * 抽象接口，规范准备接收附加责任的对象 
5.  * @author gjy 
6.  */  
7. public interface Component {  
8.     public void operation();  
9. }  

具体构件： 

Java代码  

1. package com.gjy.drector;  
2.   
3. /** 
4.  * 接收附加责任, 此类型的类可以有多个, 只对应一个Decorator类 
5.  * @author gjy 
6.  */  
7. public class ConcreteComponent implements Component {  
8.     public ConcreteComponent(){}  
9.     public void operation()  
10.     {  
11.            System.out.println("开车");  
12.     }  
13. }  

装饰角色： 

Java代码  

1. package com.gjy.drector;  
2.   
3. /** 
4.  * 装饰角色，持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口 
5.  * @author gjy 
6.  */  
7. public class Decorator implements Component {  
8.     private Component component;  
9.     public Decorator(){}  
10.   
11.     public Decorator(Component component)  
12.     {  
13.            this.component = component;  
14.     }  
15.   
16.     public void operation() {  
17.            component.operation();  
18.     }  
19. }  

具体装饰： 

Java代码  

1. package com.gjy.drector;  
2.   
3. /** 
4.  * 添加附加责任 
5.  * @author gjy 
6.  */  
7. public class ConcreteDecorator extends Decorator {  
8.   
9.     public ConcreteDecorator(){}  
10.   
11.     public ConcreteDecorator(Component component)  
12.     {  
13.            super(component);  
14.     }  
15.   
16.     public void operation()  
17.     {  
18.          this.addedOperation();  
19.          super.operation();  
20.     }  
21.   
22.     public void addedOperation()  
23.     {  
24.            System.out.println("晚上");  
25.     }  
26. }  

测试： 

Java代码  

1. package com.gjy.drector;  
2.   
3. /** 
4.  * 客户端类 
5.  * @author gjy 
6.  */  
7.   
8. public class Client {  
9.        public static void main(String[] args) {  
10.               Component component = new ConcreteComponent();  
11.               Decorator decorator = new ConcreteDecorator(component);  
12.               //客户端不变, 但已增加了责任  
13.               decorator.operation();  
14.                 
15.        }  
16. }  

输出结果： 
晚上 
开车