设计模式09 装饰模式

装饰模式(Decorator)定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

这里的“不改变现有对象结构”主要是只“使用的是同一个对象”。

装饰模式的优点有：

1、采用装饰模式扩展对象的功能比采用继承方式更加灵活。

2、可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。

原始组件：

 1 public interface Component {
 2     public void Operation();
 3 }
 4 
 5 public class ConcreteComponent implements Component {
 6     @Override
 7     public void Operation() {
 8         // TODO Auto-generated method stub
 9         System.out.println("原件调用");
10     }
11 }

装饰者：

 1 public abstract class Decorator implements Component {
 2     private Component component;
 3 
 4     public Decorator(Component component) {
 5         this.component = component;
 6     }
 7     
 8     public void Operation() {
 9         component.Operation();
10     }
11 }
12 
13 public class ConcreteDecoratorA extends Decorator {
14     public ConcreteDecoratorA(Component component) {
15         super(component);
16         // TODO Auto-generated constructor stub
17     }
18     
19     public void Operation() {
20         super.Operation();
21         addedFunction();
22     }
23 
24     public void addedFunction() {
25         System.out.println("添加具体装饰A");
26     }
27 }
28 
29 public class ConcreteDecoratorB extends Decorator {
30     public ConcreteDecoratorB(Component component) {
31         super(component);
32         // TODO Auto-generated constructor stub
33     }
34     
35     public void Operation() {
36         super.Operation();
37         addedFunction();
38     }
39 
40     public void addedFunction() {
41         System.out.println("添加具体装饰B");
42     }
43 }

调用方式：

 1 public class Client {
 2     public static void main(String[] args) {
 3         //声明组件的对象p，在下面对p进行进一步的"完善"但是不更换p的类型。
 4         Component p = new ConcreteComponent();
 5         
 6         //未添加装饰的调用
 7         p.Operation();
 8         
 9         System.out.println("----------------------");
10         //添加具体装饰A
11         p = new ConcreteDecoratorA(p);
12         p.Operation();
13         
14         System.out.println("----------------------");
15         //在装饰A的基础上，再添加具体装饰B
16         p = new ConcreteDecoratorB(p);
17         p.Operation();
18     }
19 }

执行结果：

在调用方式中可以看到，始终使用的是Component p对象，将这个对象传入Decorator的实现类中，完成对这个对象的“装饰”。