【Java】23种设计模式——23.解释器模式

定义

解释器模式(Interpreter Pattern)是一种行为设计模式，它定义了一个语言的文法，并且建立一个解释器来解释该语言中的句子。

角色

1. AbstractExpression（抽象表达式）：声明解释操作的接口
2. TerminalExpression（终结符表达式）：实现与文法中终结符相关的解释操作
3. NonterminalExpression（非终结符表达式）：实现文法规则的解释操作
4. Context（上下文）：包含解释器之外的全局信息
5. Client（客户端）：构建表示该文法定义的语言中特定句子的抽象语法树

应用场景

• 需要解释执行特定语法规则的语言
• 文法比较简单（复杂文法建议使用解释器生成器）
• 需要频繁扩展语法规则
• 特定领域语言（DSL）的实现

使用

解释器模式的完整实现

• 抽象表达式

  /**
   * 解释器模式：抽象表达式
   * @Author：lyj
   * @Date：2025/5/22 11:44
   */
  public interface Expression {
      public int interpret(Map<String, Integer> context);
  }
  

• 终结符表达式

  /**
   * 解释器模式-终结符表达式：变量
   * @Author：lyj
   * @Date：2025/5/22 11:46
   */
  public class Variable implements Expression {
      private String name;
      public Variable(String name) {
          this.name = name;
      }
  
      @Override
      public int interpret(Map<String, Integer> context) {
          return context.getOrDefault(name, 0);
      }
  }
  

  /**
   * 解释器模式-终结符表达式：常量
   * @Author：lyj
   * @Date：2025/5/22 11:48
   */
  public class Constant implements Expression {
      private int value;
      public Constant(int value)
      {
          this.value = value;
      }
  
      @Override
      public int interpret(Map<String, Integer> context) {
          return value;
      }
  }
  

• 非终结符表达式

  /**
   * 解释器模式-非终结符表达式：加法
   * @Author：lyj
   * @Date：2025/5/22 11:49
   */
  public class Add implements  Expression {
      private Expression left;        // 符号左边
      private Expression right;       // 符号右边
  
      public Add(Expression left, Expression right) {
          this.left = left;
          this.right = right;
      }
      @Override
      public int interpret(Map<String, Integer> context) {
          return left.interpret(context) + right.interpret(context);
      }
  }
  

• 客户端

// 构建表达式 ： x + y + 10
Expression expression = new Add(new Add(new Variable("x"), new Variable("y")), new Constant(10));
// 设置上下文变量值
Map<String, Integer> context = new HashMap<>();
context.put("x", 5);
context.put("y", 7);
// 解释器执行表达式
System.out.println(expression.interpret(context));  // 22