设计模式--装饰模式

动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更加灵活。

装饰模式UML

装饰模式-组成

Component抽象构件

component是一个接口或者抽象类，定义了我们最核心的对象，也就是最原始的对象。

1
2
3
4
public abstract class Component{
  //抽象方法
  public abstract void operate();
}

ConcreteComponent具体构件

ConcreteComponent是最核心、最初始，最基本的接口或者抽象类的实现，需要装饰的就是这个对象。

1
2
3
4
5
6
public class ConcreteComponent extends Component{
  @Override
  public void operate(){
     // do somethins
  }
}

Decorator装饰角色

一般为一个抽象类，用于实现一个接口或者抽象方法。在它的属性里面必然有一个private变量指向Component。

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Decorator extends Component{
  private Component component = null;
  //构造带有修饰者的函数
  public Decorator(Component _component){
    this.component= _component;
  }
  
  @Override
  public void operate(){
    this.component.operate();
  }
}

ConcreteDecorator具体装饰角色

具体的装饰类。需要把核心的东西装饰成其他东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ConcreteDecorator extends Decorator{
  public ConcreteDecorator (Component _component){
    super(_component);
  }
  
  private void method(){
    // 为Component拓展方法
  }
  
  public void operate(){
    this.method();
    super.operate();
  }
}

实际调用场景

1
2
3
4
5
6
7
8
9
public class Client{
  public static void main(String[] args){
    Component component = new ConcreteComponent();
    //进行装饰
    component = new ConcreteDecorator(component);
    //调用修饰后对象方法
    component.operate();
  }
}

装饰模式-优点

  • 装饰类和被被装饰类可以独立发展，而不会相互耦合。
  • 装饰模式是继承关系的一个替代方案。实现is-a关系(类的父子继承关系)
  • 装饰模式可以动态地拓展一个实现类的功能。符合 开闭原则。

装饰模式-缺点

多层的装饰是比较复杂的。需要减少装饰类的数量，以便降低系统的复杂度。

装饰模式-使用场景

  • 需要扩展一个类的功能，或者给一个类增加附加功能
  • 需要动态地给一个对象增加功能，这些功能也可以动态的进行撤销
  • 需要为一批兄弟类进行改装或加装功能