意图

动态给对象添加一些额外的职责。

动机

  • 有时希望能给某个对象而不是整个类的所有对象添加一些功能。
  • 继承机制不够灵活，不能控制方法增强的时机（比如英雄李白拿蓝Buff，或者红Buff，Buff持续是有时间限制的）。
  • 一种较为灵活的方式是将对象（如李白）放入一个装饰对象（如Buff），由装饰对象在合适的时机对原对象（李白）的方法（如攻击力、冷却时间）进行增强。

模式结构

装饰者模式结构.svg

效果

优点

  1. 比静态继承更灵活
    1. 可以运用添加和分离的方法，在运行时增加和删除职责。
    2. 相比而言，继承机制要求每个添加的职责创建一个子类。
    3. 多个Decorator装饰的实例对象间可以混合匹配。
  2. 避免在层次结构高层的类有太多的特征
    1. 采用即用即付方式添加职责
    2. 最初的类的功能不会很复杂，而是逐渐给它添加功能，这样使得程序不会为了不必要的特征付出代价。
    3. 可以很容易定义新的Decorator类。

缺点

  1. Decorator与它的Component不一样
    1. Decorator是一个透明包装。从对象标识出发，被装饰的组件与组件本身是有差别的。
    2. 因此，使用装饰时候，不应该依赖对象标识。
  2. 执行过程有许多小的对象产生
    1. 这些小对象差别主要是它们相互连接的方式上，而不是属性上。
    2. 对于不熟悉这种设计的人员，排错很困难。

实现

  1. 接口的一致性
    装饰对象Decorator的接口必须与它所装饰的组件Component接口是一致的。所以所有实际装饰对象ConcreteDecorator必须有一个公共父类Decorator（一般是作为抽象类）
  2. 省略抽象的Decorator类
    仅需要添加一个职责时候，抽象的Decorator类是不必要的，直接给出实际的装饰。
  3. 保持Component类的简单性
    Component接口重要作用是保证一致性，这个接口的简单性是很重要的（应该集中于定义方法，而不是存储数据，对数据表示的定义应该延迟到子类中）。否则Component类太复杂，难以大量使用，并且会导致子类无太多功能。
  4. 改变对象外壳与改变对象内核
    Decorator可以看作是对象的外壳，那么策略模式Strategy即可以视为对象的内核。
    Todo - 理解策略模式之后，进行比较归纳总结。

案例

1. 汽车功能定义

  1. public interface ICar {
  2.     /**
  3.      * 基本功能：移动
  4.      */
  5.     void move();
  6. }

2. 普通汽车实现

  1. public class Car implements ICar {
  3.     /**
  4.      * 实现基本功能：移动
  5.      */
  6.     @Override
  7.     public void move() {
  8.         System.out.println("陆地上跑");
  9.     }
  10. }

3. 超级汽车抽象

  1. /**
  2.  * 超级汽车 -> 增强的功能定义
  3.  *
  4.  * @author Jinhua
  5.  */
  6. public abstract class SuperCar implements ICar {
  8.     /**
  9.      * 拿到有基本功能汽车的引用
  10.      */
  11.     private final ICar car;
  13.     public SuperCar(ICar car) {
  14.         this.car = car;
  15.     }
  17.     /**
  18.      * 此处任然是移动功能，未进行方法增强
  19.      */
  20.     @Override
  21.     public void move() {
  22.         car.move();
  23.     }
  24. }

4. 超级汽车实现

1) AI汽车

  1. public class AiCar extends SuperCar {
  3.     /**
  4.      * 继续拿到抽象类的基本功能汽车引用，构造其属性
  5.      *
  6.      * @param car 基本功能的汽车
  7.      */
  8.     public AiCar(ICar car) {
  9.         super(car);
  10.     }
  12.     public void autoMove() {
  13.         System.out.println("自动跑");
  14.     }
  16.     /**
  17.      * 对移动方法进行了增强
  18.      */
  19.     @Override
  20.     public void move() {
  21.         super.move();
  22.         autoMove();
  23.     }
  24. }

2) 飞行汽车

  1. public class FlyCar extends SuperCar {
  3.     public FlyCar(ICar car) {
  4.         super(car);
  5.     }
  7.     public void fly() {
  8.         System.out.println("天上飞");
  9.     }
  11.     @Override
  12.     public void move() {
  13.         super.move();
  14.         fly();
  15.     }
  16. }

3) 水中汽车

  1. public class WaterCar extends SuperCar {
  3.     public WaterCar(ICar car) {
  4.         super(car);
  5.     }
  7.     public void swim() {
  8.         System.out.println("水里游");
  9.     }
  11.     @Override
  12.     public void move() {
  13.         super.move();
  14.         swim();
  15.     }
  16. }

测试主类

  1. public class Main {
  3.     public static void main(String[] args) {
  4.         System.out.println("基本功能");
  5.         ICar iCar = new Car();
  6.         iCar.move();
  8.         System.out.println("---------------");
  9.         System.out.println("增加新的功能：飞行");
  10.         ICar flyCar = new FlyCar(iCar);
  11.         flyCar.move();
  13.         System.out.println("---------------");
  14.         System.out.println("增加新的功能：水里游");
  15.         ICar waterCar = new WaterCar(iCar);
  16.         waterCar.move();
  18.         System.out.println("---------------");
  19.         System.out.println("增加两个新的功能，飞行，水里游");
  20.         ICar waterCar2 = new WaterCar(new FlyCar(iCar));
  21.         waterCar2.move();
  22.     }
  23. }

运行结果：

  1. 基本功能
  2. 陆地上跑
  3. ---------------
  4. 增加新的功能：飞行
  5. 陆地上跑
  6. 天上飞
  7. ---------------
  8. 增加新的功能：水里游
  9. 陆地上跑
  10. 水里游
  11. ---------------
  12. 增加两个新的功能，飞行，水里游
  13. 陆地上跑
  14. 天上飞
  15. 水里游