理解设计模式之装饰者模式

装饰者模式

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

先看看如何给一个类添加职责:继承。假如添加3种职责A、B、C,需要3个子类。实际情况会更复杂,这些职责并不冲突,可以相互组合,这样的话,就至少需要7个子类(不考虑顺序:A、B、C、AB、AC、BC、ABC)。这是类继承导致的类膨胀问题。

装饰者模式通过动态的组合这些职责对象优雅的化解了这个问题。
具体来说,通过A、B、C这样组合:

1
2
3
4
5
// AB
AB = new A(new B())
AC = new A(new C())
BC = new B(new C())
ABC = new A(new B(new C()))

具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public interface IComponent {
void operation();
}
public class Component implements IComponent {
@Override
public void operation() {
System.out.println("Component");
}
}
public abstract class Decorator implements IComponent {
protected IComponent component;
public Decorator(IComponent component) {
this.component = component;
}
@Override
public void operation() {
}
}
public class DecoratorA extends Decorator {
public DecoratorA(IComponent component) {
super(component);
}
@Override
public void operation() {
// Feature A code here
// ...
component.operation();
// Feature A code here
// ...
System.out.println("AAAAAAAAAAAAAA");
}
}
public class DecoratorB extends Decorator {
public DecoratorB(IComponent component) {
super(component);
}
@Override
public void operation() {
// Feature B code here
// ...
System.out.println("BBBBBBBBBB");
component.operation();
// Feature B code here
// ...
}
}
public class DecoratorC extends Decorator {
public DecoratorC(IComponent component) {
super(component);
}
@Override
public void operation() {
// Feature C code here
// ...
System.out.println("CCCCCCCCCCCC1");
component.operation();
// Feature C code here
// ...
System.out.println("CCCCCCCCCCCCC2");
}
}

装饰者模式UML类图

小结