1、定义
装饰者模式动态地将责任附加到对象上。如果要扩展功能，装饰者提供了比继承更有弹性的替代方案。
2、UML类图
装饰者模式.png
角色说明
- Component：抽象组件，接口或抽象类，被装饰者。
- ConcreteComponent：具体组件
- Decorator：装饰者抽象类，继承被装饰者的同时关联被装饰者（持有引用），同时添加自己的行为
- ConcreteDecorator：具体装饰类。
3、模式演进
以星巴克为例，有多种类型咖啡，特浓咖啡、混合咖啡、烘焙咖啡等。这里创建一个咖啡的基类，包含description与cost属性。每种类型的咖啡可能会添加多种不同的调料，比如牛奶、摩卡、泡沫....
//基类
abstract class Beverage {
private String description;
public String getDescription() {
return description;
}
public Beverage(String description) {
this.description = description;
}
abstract public double cost();
}
class Espresso extends Beverage{
public Espresso() {
super("特浓咖啡");
}
@Override
public double cost() {
return 25;
}
}
class HouseBlend extends Beverage{
public HouseBlend() {
super("混合咖啡");
}
@Override
public double cost() {
return 35;
}
}
class DarkRoast extends Beverage{
public DarkRoast() {
super("烘焙咖啡");
}
@Override
public double cost() {
return 28;
}
}
演进一
如果为第种类型的不同口味的咖啡都创建一个子类，可能会引起类爆炸（加1份奶，1份摩卡，2份奶......），对于维护来说是一种恶梦。
演进二
使用实例变量和继承来追踪这些调料,cost不再是抽象方法
abstract class Beverage {
private boolean milk,mocha,whip;//牛奶，摩卡，泡沫
private String description;
public Beverage(String description) {
this.description = description;
}
public boolean isMilk() {
return milk;
}
public void setMilk(boolean milk) {
this.milk = milk;
}
public boolean isMocha() {
return mocha;
}
public void setMocha(boolean mocha) {
this.mocha = mocha;
}
public boolean isWhip() {
return whip;
}
public void setWhip(boolean whip) {
this.whip = whip;
}
public String getDescription() {
if(isMilk()) {
description += " 牛奶";
}
if(isMocha()) {
description += " 摩卡";
}
if(isWhip()) {
description += " 泡沫";
}
return description;
}
public double cost() {
double total = 0;
if(isMilk()) {
total += 2;
}
if(isMocha()) {
total += 4;
}
if(isWhip()) {
total += 3.5;
}
return total;
};
}
class Espresso extends Beverage {
public Espresso() {
super("特浓咖啡");
}
@Override
public double cost() {
return 25 + super.cost();
}
}
class HouseBlend extends Beverage {
public HouseBlend() {
super("混合咖啡");
}
@Override
public double cost() {
return 35 + super.cost();
}
}
class DarkRoast extends Beverage {
public DarkRoast() {
super("烘焙咖啡");
}
@Override
public double cost() {
return 28 + super.cost();
}
}
客户端测试
Beverage b = new HouseBlend();
b.setMilk(true);
System.out.println(b.getDescription() + "：" + b.cost());
Beverage b2 = new Espresso();
b2.setMocha(true);
System.out.println(b2.getDescription() + "："+ b2.cost());
Beverage b3 = new DarkRoast();
b3.setWhip(true);
System.out.println(b3.getDescription() + "："+ b3.cost());
输出结果
混合咖啡 牛奶：37.0
特浓咖啡 摩卡：29.0
烘焙咖啡 泡沫：31.5
- 优点：
- 类不会爆炸
- 增加一种类型的咖啡时，不影响以前的代码，符合开闭原则
class Decaf extends Beverage{
public Decaf() {
super("低咖啡因咖啡");
}
@Override
public double cost() {
return 29 + super.cost();
}
}
- 缺点：
1、增加一种新的调料时，需要修改Beverage的cost方法，不符合开闭原则
2、如果想要加2份牛奶，貌似比较麻烦
演进三 装饰者模式
以咖啡为主体，在运行时以调料来“装饰”咖啡。比方说，顾客想要摩卡和牛奶烘焙咖啡。那么要做的是
- 拿一个烘焙咖啡对象（DarkRoast)；
- 以摩卡对象（Mocha）装饰它，变成摩卡烘焙咖啡，加上摩卡的价格；
- 以牛奶对象（Milk）装饰摩卡烘焙咖啡，变成摩卡和牛奶烘焙咖啡，加上牛奶的价格；
如果要双份牛奶，就进行下一步
- 以牛奶对象（Milk）装饰牛奶和摩卡烘焙咖啡，变成摩卡和牛奶和牛奶烘焙咖啡，再加上一份牛奶的价格；
通过以上步骤分析：
- 摩卡和牛奶是“装饰者”，烘焙咖啡就是“被装饰者”；
- 装饰完的对象可以继续装饰，说明装饰者与被装饰者的类型是一致的；
- 装饰者可以在被装饰者的行为基础上添加自己的行为（例如在烘焙咖啡基础加上摩卡的价格），这就需要装饰者持有被装饰者的引用
- 可以运行时动态地装饰对象
现在，让我们来设计星巴克咖啡
- 设计装饰者调料抽象类Condiment
- 继承被装饰者Beverage
- 关联Beverage
- 实现具体装饰者类（牛奶、摩卡.....）,并添加自己的行为
abstract class Condiment extends Beverage{
protected Beverage beverage;
public Condiment(Beverage beverage) {
super("调料");
this.beverage = beverage;
}
}
class Milk extends Condiment {
public Milk(Beverage beverage) {
super(beverage);
}
@Override
public double cost() {
return beverage.cost() + 2;
}
@Override
public String getDescription() {
return beverage.getDescription() + "牛奶";
}
}
class Mocha extends Condiment {
public Mocha(Beverage beverage) {
super(beverage);
}
@Override
public double cost() {
return beverage.cost() + 4;
}
@Override
public String getDescription() {
return beverage.getDescription() + "摩卡";
}
}
最终UML类图为
星巴克咖啡.png
客户端测试
public static void main(String[] args) {
Beverage b = new HouseBlend();
Beverage b2 = new Milk(b);//加牛奶
Beverage b3 = new Mocha(b2);//加摩卡
Beverage b4 = new Mocha(b3);//加摩卡
System.out.println(b4.getDescription() + ":" + b4.cost());
}
输出结果
混合咖啡牛奶摩卡摩卡:45.0
4、装饰者模式说明
优点：
- 用组合可以实现运行时动态扩展，比继承的编译时静态决定要灵活
- 当增加新的装饰时，可以不改动现有的代码，符合开闭原则
缺点：
- 引入装饰者会增加大量的小类，导致设计不容易被理解
其他：
- 装饰者Codiment与被装饰者Beverage并不是is-a的关系，这里用继承的目的是为了达到类型匹配，而不是利用继承获得行为，行为是通过组合进行动态添加的。
5、Android中的装饰者模式
5.1 Context
Context在Android开发中表示“上下文”。Context类是一个抽象类，具体实现在ContexImpl中。继承关系如下
Context继承结构.png
- 其中ContextWarpper继承Context并持有Context的引用，这里对应模式中的装饰者，Context为被装饰者。
public class ContextWrapper extends Context {
Context mBase;
public ContextWrapper(Context base) {
mBase = base;
}
//........
}
- Application、Service、Activity为具体装饰类。
5.2 Drawable
Drawable也是Android开发中经常用到的一个概念。是一个”可绘制东西“的抽象。用来做绘制相关的操作。跟View不同样，Drawable 不能接受任何事件以及用户交互。
Drawable继承关系.png
- DrawableWrapper为抽象装饰者，继承Drawable的同时持有Drawable类型的引用。
- ShapeDrawable、BitmapDrawable、LayerDrawable都是我们开发中用过具体实现类，只不过我们一般通过XML方式来定义。
- ClipDrawable、InsertDrawable、RotateDrawable、ScaleDrawable为具体装饰者。可实现一些额外的装饰效果。比如ClipDrwable可实现自身裁剪复制显示功能。
网友评论