目录
装饰者模式定义:
装饰模式(Decorator),动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更灵活
初计初衷:
通常可以使用继承来实现功能的扩展,如果这些需要扩展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。
要点:
装饰者与被装饰者拥有共同的超类,继承的目的是继承类型,而不是行为
装饰者模式的设计原则
对扩展开放、对修改关闭,这句话体现我如果想扩展被装饰者类的行为,无须修改装饰者抽象类,只需要继承装饰者抽象类,实现额外的一些装饰或者行为即可对被装饰者进行包装。所以:扩展体现在继承、修改体现在子类中,而不是具体的抽象类,这充分体现了依赖倒置原则,这是自己理解的装饰者模式。
大白话小结
继承可实现功能的扩展,但如果需要拓展的功能的种类很繁多(KFC肯得基订单需求),那么势必生成很多子类。装饰者模式通过:装饰者类内部含有被装饰者(组合关系),且被装饰者与装饰者都继承自共同的父类。这样可以通过将被装饰者的子类实例对象 传入-> 装饰者子类的实例对象中,拓展被装饰者继承类即可实现动态的将新功能 附加到装饰者子类实例对象上。在对象功能扩展方面,它比继承更有弹性,装饰者模式也体现了开闭原则(ocp)。
一、星巴克咖啡订单项目需求
- 咖啡种类/单品咖啡:Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)
- 调料:Milk、Soy(豆浆)、Chocolate
- 要求在扩展新的咖啡种类时,具有良好的扩展性、改动方便、维护方便
- 使用 OOP 面象对象 的来计算不同种类咖啡的费用: 客户可以点单品咖啡,也可以单品咖啡+调料组合
二、方案 1-解决星巴克咖啡订单项目(较差)
2.1 传统方案解决星巴克咖啡订单项目UML类图
较差方案:
2.2 方案 1-解决星巴克咖啡订单问题分析
- Drink 是一个抽象类,表示饮料
- des 就是对咖啡的描述, 比如咖啡的名字
- cost() 方法就是计算费用,Drink 类中做成一个抽象方法.
- Decaf 就是单品咖啡, 继承 Drink, 并实现 cost
- Espress && Milk 就是单品咖啡+调料, 这个组合很多
问题:这样设计,会有很多类,当我们增加一个单品咖啡,或者一个新的调料,类的数量就会倍增,就会出现类爆炸
三、方案 2-解决星巴克咖啡订单(好点)
前面分析到方案 1 因为咖啡单品+调料组合会造成类的倍增,因此可以做改进,将调料内置到Drink 类,这样就不会造成类数量过多。从而提高项目的维护性(如图)
方案 2-解决星巴克咖啡订单问题分析
- 方案 2 可以控制类的数量,不至于造成很多的类
- 在增加或者删除调料种类时,代码的维护量很大
- 考虑到用户可以添加多份 调料时,可以将 hasMilk 返回一个对应 int
- 考虑使用 装饰者 模式
四、装饰者模式定义
- 装饰者模式:动态的将新功能附加到对象上。在对象功能扩展方面,它比继承更有弹性,装饰者模式也体现了开闭原则(ocp)
- 这里提到的动态的将新功能附加到对象和 OCP 原则,在后面的应用实例上会以代码的形式体现。
4.1 装饰者模式原理
A、装饰者模式就像打包一个快递
- 主体:比如:陶瓷、衣服 (Component) // 被装饰者
- 包装:比如:报纸填充、塑料泡沫、纸板、木板(Decorator)
B、Component 主体:比如类似前面的 Drink
C、ConcreteComponent 和 Decorator
- ConcreteComponent:具体的主体, 比如前面的各个单品咖啡
D、Decorator: 装饰者,比如各调料
- 在如图的 Component 与 ConcreteComponent 之间,如果 ConcreteComponent 类很多,还可以设计一个缓冲层,将共有的部分提取出来,抽象层一个类。
4.2 装饰者模式解决星巴克咖啡订单
装饰者模式下的订单:2 份巧克力+一份牛奶的 LongBlack
AbstractDrink 源码示例:
public abstract class AbstractDrink {
public String des; // 描述
private float price = 0.0f;
public String getDes() {
return des;
}
public void setDes(String des) {
this.des = des;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
// 计算费用的抽象方法
// 子类来实现
public abstract float cost();
}
Coffee 源码示例:
public class Coffee extends AbstractDrink {
@Override
public float cost() {
return super.getPrice();
}
}
Espresso 源码示例:
public final class Espresso extends Coffee {
public Espresso() {
setDes(" 意大利咖啡 ");
setPrice(6.0f);
}
}
LongBlack 源码示例:
public final class LongBlack extends Coffee {
public LongBlack() {
setDes(" longBlack ");
setPrice(5.0f);
}
}
ShortBlack 源码示例:
public final class ShortBlack extends Coffee {
public ShortBlack() {
setDes(" shortBlack ");
setPrice(4.0f);
}
}
Decaf 源码示例:
public class Decaf extends Coffee {
public Decaf() {
setDes(" 无因咖啡 ");
setPrice(1.0f);
}
}
Decorator 源码示例:
public class Decorator extends AbstractDrink {
private AbstractDrink drink;
public Decorator(AbstractDrink drink) { // 组合
this.drink = drink;
}
@Override
public float cost() {
// getPrice 自己价格
return super.getPrice() + drink.cost();
}
@Override
public String getDes() {
// drink.getDes() 输出被装饰者的信息
return super.des + " " + getPrice() + " && " + drink.getDes();
}
}
Chocolate 源码示例:
// 具体的Decorator, 这里就是调味品
public class Chocolate extends Decorator {
public Chocolate(AbstractDrink drink) {
super(drink);
setDes(" 巧克力 ");
setPrice(3.0f); // 调味品的价格
}
}
Milk 源码示例:
public class Milk extends Decorator {
public Milk(AbstractDrink drink) {
super(drink);
setDes(" 牛奶 ");
setPrice(2.0f);
}
}
Soy 源码示例:
public class Soy extends Decorator {
public Soy(AbstractDrink drink) {
super(drink);
setDes(" 豆浆 ");
setPrice(1.5f);
}
}
CoffeeBar 源码示例:
public class CoffeeBar {
public static void main(String[] args) {
// 装饰者模式下的订单:2份巧克力 + 一份牛奶的LongBlack
// 1. 点一份 LongBlack
AbstractDrink order = new LongBlack();
System.out.println("费用1=" + order.getPrice());
System.out.println("描述=" + order.getDes());
// 2. order 加入一份牛奶
order = new Milk(order);
System.out.println("order 加入一份牛奶 费用 = " + order.cost());
System.out.println("order 加入一份牛奶 描述 = " + order.getDes());
// 3. order 加入一份巧克力
order = new Chocolate(order);
System.out.println("order 加入一份巧克力 费用 = " + order.cost());
System.out.println("order 加入一份巧克力 描述 = " + order.getDes());
// 4. order 加入2份巧克力
order = new Chocolate(order);
System.out.println("order 加入2份巧克力 费用 = " + order.cost());
System.out.println("order 加入2份巧克力 描述 = " + order.getDes());
System.out.println("======================================");
AbstractDrink order2 = new Decaf();
System.out.println("order2 无因咖啡 费用 = " + order2.cost());
System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
order2 = new Milk(order2);
System.out.println("order2 无因咖啡 加入一份牛奶 费用 = " + order2.cost());
System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());
}
}
运行结果,如下:
五、装饰者模式在 JDK 应用的源码分析
Java 的 IO 结构,FilterInputStream 就是一个装饰者
package com.java.z_exam.design_patterns.c04_decorator.jdk;
/**
* @Author:
* @Date: Created in 11:32 上午 2020/9/2
* @Version: 1.0
* @Modified By:
* @Description:
*/
import java.io.DataInputStream;
import java.io.FileInputStream;
public class Decorator {
public static void main(String[] args) throws Exception{
//说明
//1. InputStream 是抽象类, 类似我们前面讲的 Drink
//2. FileInputStream 是 InputStream 子类,类似我们前面的 DeCaf, LongBlack
//3. FilterInputStream 是 InputStream 子类:类似我们前面 的 Decorator 修饰者
//4. DataInputStream 是 FilterInputStream 子类,具体的修饰者,类似前面的 Milk, Soy 等
//5. FilterInputStream 类 有 protected volatile InputStream in; 即含被装饰者
//6. 分析得出在 jdk 的 io 体系中,就是使用装饰者模式
DataInputStream dis = new DataInputStream(new FileInputStream("d:\\abc.txt"));
System.out.println(dis.read());
dis.close();
}
}
六、装饰模式的应用
6.1 装饰者模式何时使用
- 在不想增加很多子类的情况下扩展类时
6.2 装饰者模式方法
- 将具体功能职责划分,同时继承装饰者模式
5.3 装饰者模式优点
- 装饰类和被装饰类可以独立发展,而不会相互耦合。它有效地把类的核心职责和装饰功能分开了
- 装饰模式是继承关系的一个替代方案
- 装饰模式可以动态地扩展一个实现类的功能
6.4 装饰者模式缺点
- 多层装饰比较复杂。比如我们现在有很多层装饰,出了问题,一层一层检查,最后发现是最里层的装饰出问题了,想想工作量都害怕
6.5 装饰者模式使用场景
- 需要扩展一个类的功能时
- 需要动态地给一个对象增加功能,并可以动态地撤销时
- 需要为一批的兄弟类进行改装或加装功能时
6.6 装饰者模式应用实例
- 旧机包装成新机,手机/电脑内部配件不变,只是换个外壳
- 换衣小游戏,人还是那个人,不断给她换衣服,还可以一层套一层的
- 孙悟空有72变,变成什么后就有了它的功能,但本质还是一只猴子
七、大白话小结
继承可实现功能的扩展,但如果需要拓展的功能的种类很繁多(KFC肯得基订单需求),那么势必生成很多子类。装饰者模式通过:装饰者类内部含有被装饰者(组合关系),且被装饰者与装饰者都继承自共同的父类。这样可以通过将被装饰者的子类实例对象 传入-> 装饰者子类的实例对象中,拓展被装饰者继承类即可实现动态的将新功能 附加到装饰者子类实例对象上。在对象功能扩展方面,它比继承更有弹性,装饰者模式也体现了开闭原则(ocp)。
文章最后,给大家推荐一些受欢迎的技术博客链接:
- JAVA相关的深度技术博客链接
- Flink 相关技术博客链接
- Spark 核心技术链接
- 设计模式 —— 深度技术博客链接
- 机器学习 —— 深度技术博客链接
- Hadoop相关技术博客链接
- 超全干货--Flink思维导图,花了3周左右编写、校对
- 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
- 请谈谈你对volatile的理解?--最近小李子与面试官的一场“硬核较量”
- 聊聊RPC通信,经常被问到的一道面试题。源码+笔记,包懂
- 深入聊聊Java 垃圾回收机制【附原理图及调优方法】
欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”,我们会有更多、且及时的资料推送给您,欢迎多多交流!