行为类模式（三）：解释器（Interpreter）

定义

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

UML

优点

1. 将每一个语法规则表示成一个类，方便事先语言。
2. 因为语法由许多类表示，所以你可以轻易地改变或扩展此语言
3. 通过在类结构中加入新的方法，可以在解释的同时增加新的行为，例如打印格式的梅花或者进行复制的程序验证。

缺点

1. 解释器模式会引起类膨胀，每个语法都要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来了非常多的麻烦。
2. 解释器模式采用递归调用方法，每个非终结符表达式只关心与自己有关的表达式，每个表达式需要知道最终的结果，必须一层一层地剥茧，无论是面向过程的语言还是面向对象的语言，递归都是在必要条件下使用的，它导致调试非常复杂。想想看，如果要排查一个语法错误，我们是不是要一个一个断点的调试下去，直到最小的语法单元。
3. 效率问题，解释器模式由于使用了大量的循环和递归，效率是个不容忽视的问题，特别是用于解析复杂、冗长的语法时，效率是难以忍受的。

应用场景

1. 重复发生的问题可以使用解释器模式。
2. 一个简单语法需要解释的场景。
3. 可以处理脚本语言和编程语言，比如正则表达式。

示例

使用解释器模式完成一个两则运算器，要求输入表达式和每个符号的值得到表达式的最终结果。

Java

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.HashMap;
 import java.util.Stack;

 public class Main
 {
     public static void main(String[] args) throws IOException
     {
         String expStr = getExpStr();
         //赋值
         HashMap<String, Integer> var = getValue(expStr);
         Calculator cal = new Calculator(expStr);
         System.out.println("运算结果为：" + expStr + "=" + cal.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 exprStr) throws IOException
     {
         HashMap<String, Integer> map = new HashMap<>();
         //解析有几个参数要传递
         for (char ch : exprStr.toCharArray())
         {
             if (ch != '+' && ch != '-')
             {
                 //解决重复参数的问题
                 if (!map.containsKey(String.valueOf(ch)))
                 {
                     System.out.print("请输入" + ch + "的值:");
                     String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                     map.put(String.valueOf(ch), Integer.valueOf(in));
                 }
             }
         }
         return map;
     }

     /**
      * 表达式基类
      */
     public static abstract class Expression
     {
         /**
          * 解析公式和数值
          * @param var key值是是公式中的参数，value值是具体的数字
          * @return 结果
          */
         public abstract int interpreter(HashMap<String, Integer> var);
     }

     /**
      * 取值表达式
      */
     public static class VarExpression extends Expression
     {
         private String key;

         public VarExpression(String _key)
         {
             key = _key;
         }

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

     /**
      * 运算表达式，仅关心左右两个值
      */
     public static abstract class SymbolExpression extends Expression
     {
         protected Expression left;
         protected Expression right;

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

     /**
      * 加法表达式处理
      */
     public static class AddExpression extends SymbolExpression
     {
         public AddExpression(Expression _left, Expression _right)
         {
             super(_left, _right);
         }

         public int interpreter(HashMap<String, Integer> var)
         {
             return super.left.interpreter(var) + super.right.interpreter(var);
         }
     }

     /**
      * 减法表达式处理
      */
     public static class SubExpression extends SymbolExpression
     {
         public SubExpression(Expression _left, Expression _right)
         {
             super(_left, _right);
         }

         public int interpreter(HashMap<String, Integer> var)
         {
             return super.left.interpreter(var) - super.right.interpreter(var);
         }
     }

     /**
      * 运算类
      */
     public static class Calculator
     {
         //定义的表达式
         private Expression expression;

         //构造函数传参,并解析
         public Calculator(String expStr)
         {
             //定义一个堆栈，安排运算的先后顺序
             Stack<Expression> stack = new Stack<Expression>();
             //表达式拆分为字符数组
             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])));
                 }
             }
             //把运算结果抛出来
             this.expression = stack.pop();
         }

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