设计模式-装饰者模式

装饰者模式-简介

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

装饰器模式通过将对象包装在装饰器类中，以便动态地修改其行为。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

举个例子：
快餐店中，有炒面、炒饭这些主食，可以额外附加 鸡蛋、培根、火腿等等这些配菜，当然加了配菜就需要多加钱，每个配菜的价格是不一样的，那么计算总价就会显得非常麻烦，如果我们采用继承的方式实现以上需求。
如下图所示：

使用继承的方式存在以下的问题：

• 拓展性不好，如果我们增加一种配菜（火腿肠），我们就需要给FriedRice和FriedNoodles分别定义一个子类，如果要新增一个快餐主食类（炒河粉），就需要定义更多的子类。
• 定义过多的子类，会导致类爆炸。

为什么需要装饰者模式？

一般的，我们为了拓展一个类经常使用继承方式来实现，由于继承为类引入了静态特征，并且随着拓展功能的增多，子类会很膨胀。
当我们在不想增加很多子类的情况下拓展类的功能，装饰者模式相比于生成子类更为灵活。

装饰者模式-结构组成

• 抽象构建角色（Component）：定义一个抽象接口以规范准备接收附加责任的对象。
• 具体构建角色（Concrete Component）：实现抽象构件，通过装饰角色为其添加一些职责。
• 抽象装饰角色（Decorator）：继承或者实现抽象构件，并且包含具体构件的实例，可以通过子类拓展具体构件的功能。
• 具体装饰角色（Concrete Decorator）：实现抽象装饰的相关方法，并且给具体构件对象添加附加的责任。

代码示例

我们使用装饰者模式对快餐店案例进行改进：
类图如下

代码如下

//快餐接口
public abstract class FastFood {
    private float price;
    private String desc;

    public FastFood() {
    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public float getPrice() {
        return price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public abstract float cost();  //获取价格
}

//炒饭
public class FriedRice extends FastFood {

    public FriedRice() {
        super(10, "炒饭");
    }

    public float cost() {
        return getPrice();
    }
}

//炒面
public class FriedNoodles extends FastFood {

    public FriedNoodles() {
        super(12, "炒面");
    }

    public float cost() {
        return getPrice();
    }
}

//配料类
public abstract class Garnish extends FastFood {

    private FastFood fastFood;

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(FastFood fastFood, float price, String desc) {
        super(price,desc);
        this.fastFood = fastFood;
    }
}

//鸡蛋配料
public class Egg extends Garnish {

    public Egg(FastFood fastFood) {
        super(fastFood,1,"鸡蛋");
    }

    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//培根配料
public class Bacon extends Garnish {

    public Bacon(FastFood fastFood) {

        super(fastFood,2,"培根");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //点一份炒饭
        FastFood food = new FriedRice();
        //花费的价格
        System.out.println(food.getDesc() + " " + food.cost() + "元");

        System.out.println("========");
        //点一份加鸡蛋的炒饭
        FastFood food1 = new FriedRice();

        food1 = new Egg(food1);
        //花费的价格
        System.out.println(food1.getDesc() + " " + food1.cost() + "元");

        System.out.println("========");
        //点一份加培根的炒面
        FastFood food2 = new FriedNoodles();
        food2 = new Bacon(food2);
        //花费的价格
        System.out.println(food2.getDesc() + " " + food2.cost() + "元");
    }
}
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

FastFood - 抽象构件角色（Component）
FriedRice、FriedNoodles - 具体构件角色（Concrete Component）
Garnish - 抽象装饰角色（Decorator）
Egg、Bacon - 具体装饰角色（Concrete Decorator）

其实我们可以发现，配料类（Garnish）本身是继承自快餐类（FastFood），所以配料类本身也是属于快餐的一种，但是配料类中包含了一个FastFood的成员变量，这个成员变量是 “需要被装饰的对象”，所以，装饰者类其实就是将 “需要被装饰的对象” 包含在自己的成员变量中，同时自己也是和这个对象继承自同一个类。

总结

优点：

• 装饰者模式可以带来比继承更加灵活的拓展功能，使用起来更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果，装饰者模式比继承更加具有良好的拓展性，完美的遵循“开闭原则”，继承是静态的附加责任，装饰者则是动态的附加责任。
• 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承模式的一个替代模式，装饰模式可以动态的拓展一个实现类的功能。

JDK源码-装饰者模式示例

IO流中的包装类使用到了装饰者模式。BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter。

我们以BufferedWriter举例来说明，先看看如何使用BufferedWriter。

public class Demo {
    public static void main(String[] args) throws Exception{
        //创建BufferedWriter对象
        //创建FileWriter对象
        FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        //写数据
        bw.write("hello Buffered");

        bw.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

BufferedWriter 使用装饰者模式对Writer的子实现类进行了增强，添加了缓冲区，提高了写数据的效率。

静态代理模式和装饰者模式的区别

• 相同点
  1. 都要实现与目标类相同的业务接口
  2. 在两个类中都要声明目标对象
  3. 都可以在不修改目标类的前提下增强方法
• 不同点
  1. 目的不同，装饰者模式是为了增强目标对象，代理模式是为了保护和隐藏对象，其次才是增强对象。
  2. 获取目标对象构建的地方不同，装饰者模式是外界传递进来，可以通过构造方法传递，而静态代理是在代理类内部创建，依次来隐藏和保护对象。