装饰者模式
案例展示：
星巴克咖啡订单项目（咖啡馆）：
- 咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式
咖啡)、Decaf(无因咖啡)
- 调料：Milk、Soy(豆浆)、Chocolate
- 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
- 使用OO的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖
啡+调料组合。
方案1-解决星巴克咖啡订单项目
方案1-解决星巴克咖啡订单问题分析：
- Drink 是一个抽象类，表示饮料
- des就是对咖啡的描述, 比如咖啡的名字
- cost() 方法就是计算费用，Drink 类中做成一个抽象方法.
- Decaf 就是单品咖啡， 继承Drink, 并实现cost
- Espress && Milk 就是单品咖啡+调料， 这个组合很多
- 问题：这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，
类的数量就会倍增，就会出现
类爆炸
装饰者模式定义
- 装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更
有弹性，装饰者模式也体现了开闭原则(ocp)
- 这里提到的动态的将新功能附加到对象和ocp原则，在后面的应用实例上会以代
码的形式体现
装饰者模式原理：
- 装饰者模式就像打包一个快递
主体：比如：陶瓷、衣服 (
Component) // 被装饰者
包装：比如：报纸填充、塑料泡沫、纸板、木板(
Decorator)
- Component
主体：比如类似前面的Drink
- ConcreteComponent和Decorator
ConcreteComponent：具体的主体，
比如前面的各个单品咖啡
Decorator: 装饰者，比如各调料.
- 在如图的Component与ConcreteComponent之间，如果
ConcreteComponent类很多,还可以设计一个
缓冲层，将共有的部分提取出来，
抽象层一个类。
用装饰者模式设计的方案：
代码实现：
Drink类–抽象类
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
2 * @author 孙一鸣 on 2020/2/10
3 */
4public abstract class Drink {
5 public String des; //描述
6 private float price=0.0f;
7
8 public String getDes() {
9 return des;
10 }
11
12 public void setDes(String des) {
13 this.des = des;
14 }
15
16 public float getPrice() {
17 return price;
18 }
19
20 public void setPrice(float price) {
21 this.price = price;
22 }
23
24 //计算费用的抽象方法
25 //子类来实现
26 public abstract float cost();
27}
28
29
30
缓冲层：
2
3
4
5
6
7
8
9
10
11
12
13
14
2 * 缓冲层
3 *
4 * @author 孙一鸣 on 2020/2/10
5 */
6public class Coffee extends Drink {
7 @Override
8 public float cost() {
9 return super.getPrice();
10 }
11}
12
13
14
这个缓冲类使用了super关键字
解析super关键字：
一.super关键字作用
1：
主要存在于子类方法中，用于指向子类对象中父类对象。
2：访问父类的属性
3：访问父类的函数
4：访问父类的构造函数
二.super注意的地方
super指向的是当前调用对象的父类。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。
三.super关键字的使用
1.子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句
三种咖啡全是抽象类Drink的子类
意大利咖啡：
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class Espresso extends Coffee {
5
6 public Espresso() {
7 setDes("意大利咖啡");
8 setPrice(6f);
9 }
10}
11
12
13
美式咖啡:
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class LongBlack extends Coffee {
5
6 public LongBlack() {
7 setDes("美式咖啡");
8 setPrice(5.0f);
9 }
10}
11
12
13
short咖啡：
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class ShortBlack extends Coffee {
5
6 public ShortBlack() {
7 setDes("short咖啡");
8 setPrice(4.0f);
9 }
10}
11
12
13
Decorator 是一个装饰类，含有一个被装饰的对象(Drink obj)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class Decorator extends Drink {
5 private Drink obj;
6
7 public Decorator(Drink obj) {//组合
8 this.obj = obj;
9 }
10
11 @Override
12 public float cost() {
13 return super.getPrice() + obj.cost();
14 }
15
16 @Override
17 public String getDes() {
18 //调味品的价格+单品咖啡的价格
19 return super.des + " "+super.getPrice() + obj.getDes();
20 }
21}
22
23
24
@Override
public String getDes() {
return super.des + " "+super.getPrice() + obj.getDes();
根据Debug方式得到、
这里调用super.getPrice 即调用父类Drink的getPrice
此时的父类 属性已经有值
public String des; = 牛奶//描述
private float price=2.0f;
装饰类：巧克力：
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class Chocolate extends Decorator {
5 public Chocolate(Drink obj) {
6 super(obj);
7 setDes("巧克力");
8 setPrice(3.0f);
9 }
10}
11
12
13
装饰类：牛奶：
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class Milk extends Decorator {
5 public Milk(Drink obj) {
6 super(obj);
7 setDes("牛奶");
8 setPrice(2.0f);
9 }
10}
11
12
13
装饰类：豆浆：
2
3
4
5
6
7
8
9
10
11
12
13
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class Soy extends Decorator {
5 public Soy(Drink obj) {
6 super(obj);
7 setDes("豆浆");
8 setPrice(1.5f);
9 }
10}
11
12
13
调用：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2 * @author 孙一鸣 on 2020/2/10
3 */
4public class CoffeeBar {
5 public static void main(String[] args) {
6 Drink order=new LongBlack();
7 System.out.println("费用1："+order.cost());
8 System.out.println("描述信息:"+order.getDes());
9
10 order = new Milk(order);
11 System.out.println("费用1："+order.cost());
12 System.out.println("描述信息:"+order.getDes());
13
14 order =new Chocolate(order);
15 order =new Chocolate(order);
16 System.out.println("费用1："+order.cost());
17 System.out.println("描述信息:"+order.getDes());
18
19 }
20}
21
22
23
演示截图:
装饰者模式在JDK应用的源码分析：
public abstract class InputStream implements Closeable{} //是一个抽象类，即Component
public class FilterInputStream extends InputStream { //是一个装饰者类Decorator
protected volatile InputStream in //被装饰的对象 }
class DataInputStream extends FilterInputStream implements DataInput { //FilterInputStream 子类，
