设计模式(十五):装饰模式

Decorator(装饰)

装饰模式 ( Decorator Pattern ),或者说叫包装模式 ( Wrapper Pattern ),作为结构型模式,其主要功能通俗的说就是在原有对象的基础上添加新的东西

装饰模式在平常生活中也是很常见的,这里就以蛋糕店做蛋糕为例吧

当我们经过一系列手工操作制作出一个基本的蛋糕胚时,蛋糕店想要将这个蛋糕卖出去,那么就需要在这个蛋糕胚上做一些装饰,比如涂上一层奶油,加一些巧克力或者水果之类的。

这样想来装饰模式也是很好理解的。当我们需要透明且动态地扩展类的功能时,我们就可以使用装饰模式

Decorator(装饰)模式的 UML 类图

  • Component : 组件接口,被装饰的原始对象
  • ConcreteComponent : 具体组件,组件接口的实现类,被装饰的具体对象
  • Decorator : 抽象装饰器,内部持有组件对象的一个实例
  • ConcreteDecorator : 具体装饰器
  • Client : 客户类

下面看一下装饰器模式的简单实现

首先就是 Component 组件接口

1
2
3
4
5
public interface Component {

void operation();

}

然后就是具体的组件,需要被装饰的对象 ConcreteComponent

1
2
3
4
5
6
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("This is Concrete Component");
}
}

简单起见,这里的操作只是输出一条语句

接着就是实现装饰器 Decorator

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class Decorator implements Component{

protected Component component;

public Decorator(Component component) {
this.component = component;
}

@Override
public void operation() {
component.operation();
}
}

这里将装饰器设置为抽象类,并且在类的内部持有一个组件对象的一个引用

最后就是具体的装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ConcreteDecorator extends Decorator {

public ConcreteDecorator(Component component) {
super(component);
}

@Override
public void operation() {
System.out.println("Add decorator operation 1");
super.operation();
System.out.println("Add decorator operation 1");
}
}

在实现的 operation() 方法中,简单起见,还是输出几条语句来达到一种在原有的功能上添加了新功能的目的,具体操作应该视具体情况而定

下面来看一下测试

1
2
3
4
5
6
7
Component component = new ConcreteComponent();
component.operation();

System.out.println("\n+--- After add decorator ---+\n");

Decorator decorator = new ConcreteDecorator(component);
decorator.operation();

分别执行了被修饰前和被修饰后的操作

装饰器模式的简单实现

介绍了装饰模式的 UML 类图结构,下面就可以结合简单的具体例子,来实现一个功能了

那么这里将以制作蛋糕为例,被装饰者将是一个蛋糕,而要实现的装饰操作就是,在原有的蛋糕基础上,添加新的东西以达到装饰成新蛋糕的目的

首先就是蛋糕类接口 Cake

1
2
3
public interface Cake {
void make();
}

具体的蛋糕,或者说是蛋糕胚 CakeEmbryo

1
2
3
4
5
6
7
public class CakeEmbryo implements Cake {

@Override
public void make() {
System.out.println("Baking Cakes");
}
}

抽象装饰器 DecorateCake

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class DecorateCake implements Cake {

Cake cake;

public DecorateCake(Cake cake) {
this.cake = cake;
}

@Override
public void make() {
cake.make();
}
}

接下来就可以更具具体情况来对原有的东西进行装饰(添加新的东西)

装饰成巧克力蛋糕 ChocolateCake

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ChocolateCake extends DecorateCake {

public ChocolateCake(Cake cake) {
super(cake);
}

@Override
public void make() {
addChocolate();
super.make();

}

private void addChocolate() {
System.out.println("Add Chocolate");
}
}

装饰成水果蛋糕

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class FruitCake extends DecorateCake {

public FruitCake(Cake cake) {
super(cake);
}

@Override
public void make() {
addSomeFruit();
super.make();
}

private void addSomeFruit() {
System.out.println("Add some fruit");
}
}

最后就可以进行测试了

1
2
3
4
5
6
7
8
9
10
Cake cake = new CakeEmbryo();
cake.make();

System.out.println("\n+--- Decorate Chocolate Cake ---+");
DecorateCake chocolateCake = new ChocolateCake(cake);
chocolateCake.make();

System.out.println("\n+--- Decorate Fruit Cake ---+");
DecorateCake fruitCake = new FruitCake(cake);
fruitCake.make();

测试输出

1
2
3
4
5
6
7
8
9
Baking Cakes

+--- Decorate Chocolate Cake ---+
Add Chocolate
Baking Cakes

+--- Decorate Fruit Cake ---+
Add some fruit
Baking Cakes

可以看到,经过使用装饰器模式,每一个被装饰过后的类的操作就具有了新的功能

总结

如果了解过 代理模式 的话,会发现装饰模式与代理模式是十分相似的,但是本质是有区别的

  • 装饰模式 : 是以对客户端透明的方式扩展对象的功能,是继承方式的一种替代方案。装饰模式应该为所装饰的对象的增强功能
  • 代理模式 : 给一个对象提供一个代理对象,并由代理对象来控制对原有对象的引用。代理模式对代理的对象施加控制,但不对对象本身的功能进行增强

END.


源码地址

文章作者: Inno Fang
文章链接: https://innofang.github.io/2017/05/05/设计模式-十五-装饰模式/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-ND 4.0 许可协议。转载请注明来自 Inno's Blog