设计模式——解释器模式-CFANZ编程社区

模式介绍

在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器。
解释器模式(Interpreter Pattern) :是指给定一个语言(表达式),定义它的文法的一种表示，并定义一个解释器,使用该解释器来解释语言中的句子(表达式)。
应用场景
- 应用可以将一一个需要解释执行的语言中的句子表示为一个抽象语法树
- 一些重复出现的问题可以用一种简单的语言来表达。
- 一个简单语法需要解释的场景。
这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等。

UML类图

类图解析：

Context:是环境角色，含有解释器之外的全局信息。
AbstractExpression:抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享。
TerminalExpression:为终结符表达式，实现与文法中的终结符相关的解释操作。
NonTermialExpression:为非终结符表达式，为文法中的非终结符实现解释操作。
说明:输入Context 和 TerminalExpression信息通过Client输入即可

解释器模式案例

背景介绍:加减运算器，运算包含加法和减法如输入 a+b-c 会先给a、b、c赋值，最终得出结果

Expression抽象类

/**
 * 抽象类表达式，通过Hashmap键值对，可以获取到变量的值
 */
public abstract class Expression {
   /**
    *     解释公式和数,key,公式表达式中的参数【a,b,c】,value就是具体值
    *     { a = 10, b = 20}
    */
   public abstract int interpreter(HashMap<String, Integer> var);
}

VarExpression终结符表达式

public class VarExpression extends Expression {

   private String key; 

   public VarExpression(String key) {
      this.key = key;
   }

   @Override
   public int interpreter(HashMap<String, Integer> var) {
      return var.get(this.key);
   }
}

SymbolExpression加减法运算抽象类

public class SymbolExpression extends Expression {

   protected Expression left;
   protected Expression right;

   public SymbolExpression(Expression left, Expression right) {
      this.left = left;
      this.right = right;
   }

   @Override
   public int interpreter(HashMap<String, Integer> var) {
      // TODO Auto-generated method stub
      return 0;
   }
}

SymbolExpression子类AddExpression、SubExpression

public class AddExpression extends SymbolExpression  {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    public int interpreter(HashMap<String, Integer> var) {
        // 通过多态调用VarExpression
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

public class SubExpression extends SymbolExpression {

   public SubExpression(Expression left, Expression right) {
      super(left, right);
   }

   public int interpreter(HashMap<String, Integer> var) {
      // 通过多态调用VarExpression
      return super.left.interpreter(var) - super.right.interpreter(var);
   }
}

Calculator计算类

public class Calculator {

   // 定义表达式
   private Expression expression;

   // 构造函数传参，并解析
   public Calculator(String expStr) {
      // 安排运算先后顺序
      Stack<Expression> stack = new Stack<>();
      char[] charArray = expStr.toCharArray();

      Expression left = null;
      Expression right = null;
      for (int i = 0; i < charArray.length; i++) {
         switch (charArray[i]) {
            case '+': // 加法
               left = stack.pop();
               right = new VarExpression(String.valueOf(charArray[++i]));// 获取右数值
               stack.push(new AddExpression(left, right));//嵌套
               break;
            case '-': 
               left = stack.pop();
               right = new VarExpression(String.valueOf(charArray[++i]));
               stack.push(new SubExpression(left, right));
               break;
            default:
               stack.push(new VarExpression(String.valueOf(charArray[i])));
               break;
         }
      }
      this.expression = stack.pop();
   }

   public int run(HashMap<String, Integer> var) {
      return this.expression.interpreter(var);
   }
}

ClientTest测试类

public class ClientTest {

   public static void main(String[] args) throws IOException {
      // TODO Auto-generated method stub
      String expStr = getExpStr();
      HashMap<String, Integer> var = getValue(expStr);
      Calculator calculator = new Calculator(expStr);
      System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
   }

   // 获得表达式
   public static String getExpStr() throws IOException {
      System.out.print("请输入表达式：");
      return (new BufferedReader(new InputStreamReader(System.in))).readLine();
   }

   // 获得值映射
   public static HashMap<String, Integer> getValue(String expStr) throws IOException {
      HashMap<String, Integer> map = new HashMap<>();
      for (char ch : expStr.toCharArray()) {
         if (ch != '+' && ch != '-') {
            if (!map.containsKey(String.valueOf(ch))) {
               System.out.print("请输入" + String.valueOf(ch) + "的值：");
               String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
               map.put(String.valueOf(ch), Integer.valueOf(in));
            }
         }
      }

      return map;
   }
}

实现结果: