Java设计模式之装饰器模式

装饰器模式

介绍

装饰器模式（Decorator Pattern）指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰类来包装原有的类，并提供额外的功能。

引入问题

举个例子，某公司拥有一众程序员。

public class Coder() {
    public void code() {
        System.out.println("会写代码的程序员...");
    }
}

现在，业务需要有Java语言code能力的程序员。按照面向对象的设计思想，一般的做法是新增一个JavaCoder类，继承Coder类

public class JavaCoder extends Coder {
    public void codeJava() {
        System.out.println(" 会使用Java语言....");
    }
}

然后，又需要有Go语言code能力的程序员，照例需要新添加一个GoCoder类，继承Coder类

public class GoCoder extends Coder {
    public void codeGo() {
        System.out.println(" 会使用Go语言....");
    }
}

这时，如果现在需要既有Java语言code能力，又有Go语言code能力的程序员，又需要创建一个JavaAndGoCoder类，这样就会导致一旦有需求增加或变更，类数量就会暴增。如果已经存在的类能复用就好了。

解决方案

装饰器模式就是为了解决上述问题而生的。它通过把复杂的功能简单化，分散化，然后在运行期间，根据需要来动态组合。装饰器模式的通用类图如下：

在装饰器模式中一共有以下四种角色

• Component
  增加功能时的核心角色。负责定义功能接口。
• ConcreteComponent
  实现Component角色所定义的接口。
• Decorator
  该角色与Component角色有相同的接口，且在该角色内保存了Component角色。
• ConcreteDecorator
  该角色是Decorator角色的具体实现。

以上述程序员的问题为例，我们使用装饰器模式为Coder类动态添加方法

• Coder类（扮演Component角色）
  

  public abstract class Coder { 
  
      public abstract void code(); 
  
  }

• ConcreteCoder类（扮演ConcreteComponent角色）
  

  public class ConcreteCoder extends Coder { 
  
      @Override 
  
      public void code() { 
  
          System.out.println("会写代码的程序员..."); 
  
      } 
  
  }

• CoderDecorator类（扮演Decorator角色）
  

  public abstract class CoderDecorator extends Coder { 
  
      private Coder coder; 
  
      public CoderDecorator(Coder coder) { 
  
          this.coder = coder; 
  
      } 
  
      @Override 
  
      public void code() { 
  
          coder.code(); 
  
      } 
  
  }

• JavaCoder类（扮演ConcreteDecorator角色）
  

  public class JavaCoder extends CoderDecorator { 
  
      public JavaCoder(Coder coder) { 
  
          super(coder); 
  
      } 
  
      public void codeJava() { 
  
          System.out.println("用Java语言写代码..."); 
  
      } 
  
      @Override 
  
      public void code() { 
  
          super.code(); 
  
          codeJava(); 
  
      } 
  
  }

• GoCoder类（扮演ConcreteDecorator角色）
  

  public class GoCoder extends CoderDecorator { 
  
      public GoCoder(Coder coder) { 
  
          super(coder); 
  
      } 
  
      public void codeGo() { 
  
          System.out.println("用Go语言写代码..."); 
  
      } 
  
      @Override 
  
      public void code() { 
  
          super.code(); 
  
          codeGo(); 
  
      } 
  
  }

此时，当我们需要既有Java语言code能力，又有Go语言code能力的程序员时，只要用CoderDecorator类和CoderDecorator类去装饰ConcreteCoder类就行了，而不需要再新增类。

• 调用类

  public class Client {
      public static void main(String[] args) {
          Coder coder = new GoCoder(new JavaCoder(new ConcreteCoder()));
          coder.code();
      }
  }

• 输出结果

  会写代码的程序员...
  用Java语言写代码...
  用Go语言写代码...
  

到此，我们就通过装饰器模式实现了功能的动态增加。

装饰器模式总结

• 优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
• 缺点：多层装饰比较复杂。