解释器(Interpreter)

定义

给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。

能解决什么问题

类似正则表达式，是为了解决一类特定，而且重复使用比较多的问题。
和组合模式的区别是，解释器模式侧重于解决文法和元素的组合，并且组成元素多于组合模式（多一个Context类，用来生产解释器）。

优缺点

解释器模式是一种类行为型模式，其主要优点如下：

  1. 扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
  2. 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

解释器模式的主要缺点如下：

  1. 执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。
  2. 会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
  3. 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

特点

解释器模式包含以下主要角色：

  1. 抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
  2. 终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
  3. 非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
  4. 环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
  5. 客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

类图

模式23-解释器(Interpreter) - 图1

代码实例

  1. /**
  2.  * 抽象解释器
  3.  * 用来解释0-9的加减法
  4.  */
  5. public interface Expression {
  7.     int interpret();
  8. }
  10. /**
  11.  * 最终解释器
  12.  * 用来把字符串转为数字
  13.  */
  14. public class TerminalExpression implements Expression{
  16.     private String info;
  18.     public TerminalExpression(String info) {
  19.         this.info = info;
  20.     }
  22.     @Override
  23.     public int interpret() {
  24.         return Integer.parseInt(info);
  25.     }
  26. }
  28. /**
  29.  * 非终端解释器
  30.  * 含有左右2个解释器的
  31.  */
  32. public abstract class LeftRightExpression implements Expression{
  34.     protected Expression left;
  35.     protected Expression right;
  37.     // 必须由左右2个解释器构件
  38.     public LeftRightExpression(Expression left, Expression right) {
  39.         this.left = left;
  40.         this.right = right;
  41.     }
  42. }
  44. /**
  45.  * 非终端解释器
  46.  * 加法解释器
  47.  */
  48. public class AddExpression extends LeftRightExpression {
  50.     public AddExpression(Expression left, Expression right) {
  51.         super(left, right);
  52.     }
  54.     @Override
  55.     public int interpret() {
  56.         return left.interpret() + right.interpret();
  57.     }
  58. }
  60. /**
  61.  * 非终端解释器
  62.  * 减法解释器
  63.  */
  64. public class SubtractExpression extends LeftRightExpression {
  66.     public SubtractExpression(Expression left, Expression right) {
  67.         super(left, right);
  68.     }
  70.     @Override
  71.     public int interpret() {
  72.         return left.interpret() - right.interpret();
  73.     }
  74. }
  76. /**
  77.  * 环境类
  78.  * 用来生成解释器
  79.  */
  80. public class Context {
  82.     private Expression expression;
  84.     /**
  85.      * 对字符串运算进行解析
  86.      *
  87.      * @param info 字符串运算
  88.      * @return 计算记过
  89.      */
  90.     public int calculate(String info) {
  91.         this.expression = createExpression(info);
  92.         return expression.interpret();
  93.     }
  95.     /**
  96.      * 生成解释器
  97.      *
  98.      * @param info “1+2-3” 类似这种
  99.      * @return 解释器
  100.      */
  101.     private Expression createExpression(String info) {
  102.         Stack<Expression> stack = new Stack<>();
  103.         char[] chars = info.toCharArray();
  104.         for (int i = 0; i < chars.length; i++) {
  105.             char a = chars[i];
  106.             switch (a) {
  107.                 case '+':
  108.                     Expression left = stack.pop();
  109.                     Expression right = new TerminalExpression(String.valueOf(chars[++i]));
  110.                     stack.push(new AddExpression(left, right));
  111.                     break;
  112.                 case '-':
  113.                     Expression left2 = stack.pop();
  114.                     Expression right2 = new TerminalExpression(String.valueOf(chars[++i]));
  115.                     stack.push(new SubtractExpression(left2, right2));
  116.                     break;
  117.                 case ' ':
  118.                     break;
  119.                 default:
  120.                     stack.push(new TerminalExpression(String.valueOf(a)));
  121.                     break;
  122.             }
  123.         }
  124.         return stack.pop();
  125.     }
  127. }
  129. public class Client {
  131.     public static void main(String[] args) {
  132.         Context context = new Context();
  133.         String info = "1+7+5-3+1";
  134.         int calculate = context.calculate(info);
  135.         System.out.println(info + "=" + calculate);
  136.     }
  137. }
  139. > Task :Client.main()
  140. 1+7+5-3+1=11