介绍

Interpreter 模式 也叫 解释器模式

行为模式之一

是一个特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。

简单说，Interpreter模式是一种简单的语法解释器结构

应用场景

• 当有一个语言需要解释执行，并且你可将该语言中的句子表示为以恶搞抽象语法树时，可以使用解释器模式，而当存在以下情况时该模式效果最好：

  • 该文法简单对于复杂的文法，文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。他们无需构建抽象语法树几个解释表达式，这样可以节省空间而且还可能节省时间
  • 效率不是解释器达到的关键目的，最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将他们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下，转换器仍可用解释器模式实现，该模式仍是有用的

• 解释器模式在实际业务开发场景比较少

结构图

角色和职责

• Context
  • 解释器上下文环境类。用来存储解释器的上下文环境
• AbstractExpression
  • 解释器抽象类
• ConcreteExpression
  • 解释器具体实现类

代码实现

• 代码UML

• context

  /**
   * 角色：Context
   */
  public class Context {
  
      private String input;
  
      private int out;
  
      public Context(String input) {
          this.input = input;
      }
  
      public String getInput() {
          return input;
      }
  
      public void setInput(String input) {
          this.input = input;
      }
  
      public int getOut() {
          return out;
      }
  
      public void setOut(int out) {
          this.out = out;
      }
  
      @Override
      public String toString() {
          return "Context{" +
                  "input='" + input + '\'' +
                  ", out=" + out +
                  '}';
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38

• AbstractExpression

  /**
   * 角色：AbstractExpression 抽象解释器
   */
  public abstract class AbstractExpression {
  
      public abstract void interpret(Context context);
  }
  
  1
  2
  3
  4
  5
  6
  7
  8

• ConcreteExpression

  /**
   * 角色：ConcreteExpression 解释器具体实现类
   **/
  public class PlusExpression extends AbstractExpression{
  
      @Override
      public void interpret(Context context) {
          // 提示信息
          System.out.println("自动递增");
          // 获得上下文环境
          String input = context.getInput();
          // 进行类型转换
          int intInput = Integer.parseInt(input);
          // 进行递增
          intInput++;
          // 对上下文环境重新赋值
          context.setInput(String.valueOf(intInput));
          context.setOut(intInput);
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

  /**
   * 角色：ConcreteExpression 解释器具体实现类
   **/
  public class MinusExpression extends AbstractExpression{
  
      @Override
      public void interpret(Context context) {
          // 提示信息
          System.out.println("自动递减");
          // 获得上下文环境
          String input = context.getInput();
          // 进行类型转换
          int intInput = Integer.parseInt(input);
          // 进行递减
          intInput--;
          // 对上下文环境重新赋值
          context.setInput(String.valueOf(intInput));
          context.setOut(intInput);
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

• 测试

  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * 测试
   */
  public class ClientTest {
  
      public static void main(String[] args) {
          String number = "20";
          Context context = new Context(number);
  
          AbstractExpression plusExpression = new PlusExpression();
          plusExpression.interpret(context);
          System.out.println(context);
  
          AbstractExpression minusExpression = new MinusExpression();
          minusExpression.interpret(context);
          System.out.println(context);
  
          System.out.println("---------------------");
          // 集合持续执行形式（模拟解释器语法树）
          List<AbstractExpression> expressionsTree = new ArrayList<>();
          expressionsTree.add(plusExpression);
          expressionsTree.add(plusExpression);
          expressionsTree.add(plusExpression);
          expressionsTree.add(plusExpression);
          for (AbstractExpression e : expressionsTree) {
              e.interpret(context);
              System.out.println(context);
          }
      }
  
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35

• 输出

  自动递增
  Context{input='21', out=21}
  自动递减
  Context{input='20', out=20}
  ---------------------
  自动递增
  Context{input='21', out=21}
  自动递增
  Context{input='22', out=22}
  自动递增
  Context{input='23', out=23}
  自动递增
  Context{input='24', out=24}
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13