给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。

    【角色】

    • 抽象解释器（AbstractExpression）：声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
    • 终结解释器（TerminalExpression）：实现与文法中的终结符相关联的解释操作。一个句子中的每一个终结符需要该类的一个实例。
    • 非终结解释器（NonterminalExpression）：对文法中的规则的解释操作。
    • 环境角色（Context）：包含解释器之外的一些全局信息。

    【优点】

    • 扩展性好，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。

    【缺点】

    • 会引起类膨胀。
    • 采用递归调用方法，将会导致调试非常复杂。

    • 使用了大量的循环和递归，效率是一个不容忽视的问题。

      1. /**
      2. * 抽象表达式类（抽象解释器）
      3. */
      4. public abstract class Expression {
      5.   /**
      6.    * 解释表达式
      7.    */
      8.   abstract int interpreter(Map<String, Integer> var);
      9. }
      1. /**
      2. * 变量解释器（终结解释器）
      3. */
      4. public class VarExpression extends Expression {
      6.   private String key;
      8.   public VarExpression(String key) {
      9.       this.key = key;
      10.   }
      12.   @Override
      13.   int interpreter(Map<String, Integer> var) {
      14.       return var.get(this.key);
      15.   }
      16. }
      1. /**
      2. * 符号解释器（非终结解释器）
      3. */
      4. public class SymbolExpression extends Expression {
      6.   protected Expression left;
      8.   protected Expression right;
      10.   public SymbolExpression(Expression left, Expression right) {
      11.       this.left = left;
      12.       this.right = right;
      13.   }
      15.   @Override
      16.   int interpreter(Map<String, Integer> var) {
      17.       return 0;
      18.   }
      19. }
      1. /**
      2. * 加号解析器
      3. */
      4. public class AddExpression extends SymbolExpression {
      6.   public AddExpression(Expression left, Expression right) {
      7.       super(left, right);
      8.   }
      10.   @Override
      11.   int interpreter(Map<String, Integer> var) {
      12.       return left.interpreter(var) + right.interpreter(var);
      13.   }
      14. }
      1. /**
      2. * 减号解析器
      3. */
      4. public class SubExpression extends SymbolExpression {
      6.   public SubExpression(Expression left, Expression right) {
      7.       super(left, right);
      8.   }
      10.   @Override
      11.   int interpreter(Map<String, Integer> var) {
      12.       return left.interpreter(var) - right.interpreter(var);
      13.   }
      14. }
      1. /**
      2. * 计算器（环境角色）
      3. */
      4. public class Calculator {
      6.   private Expression expression;
      8.   /**
      9.    * 构建计算器
      10.    */
      11.   public Calculator(String expStr) {
      12.       // 运算先后顺序
      13.       Stack<Expression> stack = new Stack<>();
      14.       // 表达式拆分为字符数组
      15.       char[] charArray = expStr.toCharArray();
      17.       Expression left = null;
      18.       Expression right = null;
      20.       for (int i = 0; i < charArray.length; i++) {
      21.           switch (charArray[i]) {
      22.               case '+':
      23.                   left = stack.pop();
      24.                   right = new VarExpression(String.valueOf(charArray[++i]));
      25.                   stack.push(new AddExpression(left, right));
      26.                   break;
      27.               case '-':
      28.                   left = stack.pop();
      29.                   right = new VarExpression(String.valueOf(charArray[++i]));
      30.                   stack.push(new SubExpression(left, right));
      31.                   break;
      32.               default:
      33.                   stack.push(new VarExpression(String.valueOf(charArray[i])));
      34.                   break;
      35.           }
      36.       }
      37.       this.expression = stack.pop();
      38.   }
      40.   /**
      41.    * 运算
      42.    */
      43.   public int run(Map<String, Integer> var) {
      44.       return this.expression.interpreter(var);
      45.   }
      46. }
      1. public class InterpreterTest {
      2.   public static void main(String[] args) {
      3.       // 计算器
      4.       String expStr = "a+b-c";
      5.       Calculator calculator = new Calculator(expStr);
      6.       Map<String, Integer> var = new HashMap<>();
      7.       var.put("a", 10);
      8.       var.put("b", 4);
      9.       var.put("c", 6);
      10.       System.out.println("表达式：" + expStr + "=" + calculator.run(var));
      11.   }
      12. }
      13. ----输出----
      14. 表达式：a+b-c=8