【23种设计模式】9装饰者模式

描述：对象易于动态添加新功能，开闭原则
优点：装饰类和被装饰类解耦，代替继承，动态展类的功能
缺点：过度使用，增加复杂度

应用：给类扩展功能，动态增加和删除功能，基础功能组合的新功能

---

classDiagram
  class Component {
    <>
    +operate()* viod
  }
  class ConcreteComponent{
    +operate() void
  }
  class Decorator{
    <>
    -component : Component
    constructor(component : Component )
    +operate() void
  }
  class ConcreteDecorator{
    constructor(component : Component)
    -methodA() void
    +operate() void
  }
  Component <|-- ConcreteComponent :继承
  Component <|-- Decorator :继承
  Component --o Decorator :聚合
  Decorator <|-- ConcreteDecorator :继承

• 抽象类
  • 具体类继承抽象类
• 装饰器抽象类
  • 实现具体装饰者
• 实例化具体类
  • 对实例进行装饰，

// 抽象构件
abstract class Component {
    public abstract operate() : void;
}
// 具体构件
class ConcreteComponent extends Component {
    public operate() : void {
        console.log('do something');
    }
}
// 装饰角色
abstract class Decorator extends Component {
    private component : Component = null;
    constructor(component : Component ) {
        super();
        this.component = component;
    }
    public operate() : void {
        this.component.operate();
    }
}
// 具体装饰者
class ConcreteDecoratorA extends Decorator {
    constructor(component : Component) {
        super(component);
    }
    // 定义自己的修饰方法
    private methodA() : void {
        console.log('methodA修饰');
    }
    // 重写父类方法
    public operate() : void {
        this.methodA();
        super.operate();
    }
}
class ConcreteDecoratorB extends Decorator {
    constructor(component : Component) {
        super(component);
    }
    // 定义自己的修饰方法
    private methodB() : void {
        console.log('methodB修饰');
    }
    // 重写父类方法
    public operate() : void {
        this.methodB();
        super.operate();
    }
}
function main() {
    let component : Component = new ConcreteComponent();
    // 第一次装饰
    component = new ConcreteDecoratorA(component);
    // 第二次装饰
    component = new ConcreteDecoratorB(component);
    // 装饰后运行
    component.operate();
}