总阅读量:次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 http://www.cnblogs.com/chenssy/archive/2013/05/23/3094138.html 「小明哥」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

​ 我们都知道，可以使用两种方式给一个类或者对象添加行为。

​ 一是使用继承。继承是给一个类添加行为的比较有效的途径。通过使用继承，可以使得子类在拥有自身方法的同时，还可以拥有父类的方法。但是使用继承是静态的，在编译的时候就已经决定了子类的行为，我们不便于控制增加行为的方式和时机。

​ 二是使用关联。组合即将一个对象嵌入到另一个对象中，由另一个对象来决定是否引用该对象来扩展自己的行为。这是一种动态的方式，我们可以在应用程序中动态的控制。

​ 与继承相比，关联关系的优势就在于不会破坏类的封装性，且具有较好的松耦合性，可以使系统更加容易维护。但是它的缺点就在于要创建比继承更多的对象。

一、基本定义

​ 装饰者模式，动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。

二、模式结构

​ 装饰者模式UML结构图。

img

​ Component: 抽象构件。是定义一个对象接口，可以给这些对象动态地添加职责。

​ ConcreteComponent:具体构件。是定义了一个具体的对象，也可以给这个对象添加一些职责。

​ Decorator: 抽象装饰类。是装饰抽象类，继承了Component,从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator存在的。

​ ConcreteDecorator:具体装饰类，起到给Component添加职责的功能。

三、实现装饰者模式

​ 情景模式：星巴兹以扩张速度快而闻名。在里面购买咖啡时，可以要求在其中加入各种调料，星巴兹会根据所加入的调料收取不同的费用，也就是说不同的咖啡与调料之间有N多不同的组合方式。每种咖啡和调料都有不同的收费。如果这个时候我们使用继承方式，则会陷入无以复加的地步。这里会有N多个类，出现“类爆炸”现象。

​ 结构图如下：

img

​ 装饰者模式提供了一个比较好的解决方案。

img

编码实现：

​ Component Beverage.java

1. public abstract class Beverage {
2. ​    protected String description = "Unknown Beverage";
3.
4. ​    public String getDescription() {
5. ​        return description;
6. ​    }
7.
8. ​    public abstract double cost();
9. }

​ 四个组件：HouseBlend.java

1. public class HouseBlend extends Beverage {
2.
3. ​    public HouseBlend(){
4. ​        description = "HouseBlend";
5. ​    }
6. ​
7. ​    @Override
8. ​    public double cost() {
9. ​        return 0.89;
10. ​    }
11.
12. }

​ DarkRoast.java

1. public class DarkRoast extends Beverage {
2. ​    public DarkRoast(){
3. ​        description = "DarkRoast";
4. ​    }
5. ​    @Override
6. ​    public double cost() {
7. ​        return 1.05;
8. ​    }
9.
10. }

​ Espresso.java

1. public class DarkRoast extends Beverage {
2. ​    public DarkRoast(){
3. ​        description = "DarkRoast";
4. ​    }
5. ​    @Override
6. ​    public double cost() {
7. ​        return 1.05;
8. ​    }
9.
10. }

​ Decat.java

1. public Decat(){
2. ​    description = "Decat";
3. }
4. ​
5. @Override
6. public double cost() {
7. ​    return 0.99;
8. }

​ CondimentDecorator.java

1. public abstract class CondimentDecorator extends Beverage{
2. ​    public abstract String getDescription();
3. }

​ Milk.java

1. public class Milk extends CondimentDecorator {
2. ​    Beverage beverage;
3. ​
4. ​    public Milk(Beverage beverage){
5. ​        this.beverage = beverage;
6. ​    }
7. ​
8. ​    @Override
9. ​    public String getDescription() {
10. ​        return beverage.getDescription() + " , Milk";
11. ​    }
12.
13. ​    @Override
14. ​    public double cost() {
15. ​        return beverage.cost() + 0.3;
16. ​    }
17. }

​ Mocha.java

1. public class Mocha extends CondimentDecorator {
2. ​    Beverage beverage;
3. ​    public Mocha(Beverage beverage){
4. ​        this.beverage = beverage;
5. ​    }
6. ​
7. ​    @Override
8. ​    public String getDescription() {
9. ​        return beverage.getDescription() + " , Mocha";
10. ​    }
11.
12. ​    @Override
13. ​    public double cost() {
14. ​        return beverage.cost() + 0.20;
15. ​    }
16.
17. }

​ Soy.java

  1. public class Soy extends CondimentDecorator{
  2. ​ Beverage beverage;
  3. ​ public Soy(Beverage beverage) {
  4. ​ this.beverage = beverage;
  5. ​ }
  6. ​ @Override
  7. ​ public String getDescription() {
  8. ​ return beverage.getDescription() + " , Soy";
  9. ​ }
  11. ​ @Override
  12. ​ public double cost() {
  13. ​ return beverage.cost() + 0.10;
  14. ​ }
  16. }

​ Whip.java

1. public class Whip extends CondimentDecorator {
2. ​    Beverage beverage;
3. ​    public Whip(Beverage beverage){
4. ​        this.beverage = beverage;
5. ​    }
6. ​    @Override
7. ​    public String getDescription() {
8. ​        return beverage.getDescription() + " , Whip";
9. ​    }
10.
11. ​    @Override
12. ​    public double cost() {
13. ​        return beverage.cost() + 0.20;
14. ​    }
15.
16. }

​ 测试程序

1. public class StarbuzzCoffee {
2.
3. ​    /
4. ​     * @param args
5. ​     */
6. ​    public static void main(String[] args) {
7. ​        Beverage beverage = new Espresso();
8. ​        System.out.println(beverage.getDescription() + " $" + beverage.cost());
9. ​
10. ​        Beverage beverage2 = new DarkRoast();
11. ​        beverage2 = new Mocha(beverage2);
12. ​        beverage2 = new Mocha(beverage2);
13. ​        beverage2 = new Whip(beverage2);
14. ​        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
15. ​    }
16.
17. }

​ 运行结果

img

四、装饰者模式的优缺点

优点

1、装饰者模式可以提供比继承更多的灵活性

​2、可以通过一种动态的方式来扩展一个对象的功能，在运行时选择不同的装饰器，从而实现不同的行为。

3、通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。可以使用多个具体装饰类来装饰同一对象，得到功能更为强大的对象。

4、具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”。

缺点

1、会产生很多的小对象，增加了系统的复杂性

2、这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。

五、装饰者模式的适用场景

​1、在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

2、需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

六、总结

1、 组合和委托可以在运行时动态的添加新的行为，而继承是静态的，在系统编译时就已经决定了对象的行为。

2、装饰者模式意味着一群装饰者类，这些类用来包装具体组件

3、装饰者可以在被装饰者的行为前面或者后面加上自己的行为，甚至可以将被装饰者的行为整个取代掉，从而达到特定的目的。

4、可以用多个装饰者包装一个组件。

5、装饰者一般对于组件的客户是透明的，除非客户程序依赖于组件的具体类型。

6、装饰者会导致设计中出现许多的小对象，如果过度的使用，会让系统变得更加复杂。

7、装饰者和被装饰者对象有相同的超类型。

666. 彩蛋

如果你对 设计模式 感兴趣，欢迎加入我的知识一起交流。

知识星球

文章目录
  1. 1. 一、基本定义
  2. 2. 二、模式结构
  3. 3. 三、实现装饰者模式
  4. 4. 四、装饰者模式的优缺点
    1. 4.1. 优点
    2. 4.2. 缺点
  5. 5. 五、装饰者模式的适用场景
  6. 6. 六、总结
  7. 7. 666. 彩蛋