描述

解释器模式是类的行为模式。给定一个语言之后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。

简介

解释器模式类图

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

角色

抽象表达式(Expression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
终结符表达式(TerminalExpression)角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
非终结符表达式(NonterminalExpression)角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
环境(Context)角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。

优缺点

优点

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

缺点

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

使用场景

当语言的文法较为简单，且执行效率不是关键问题时。
当问题重复出现，且可以用一种简单的语言来进行表达时。
当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。

示例

/**
* 环境角色
*/
public class Context {
   private Map<Expression, Integer> map = new HashMap<Expression, Integer>();

   public void add(Expression s, Integer value) {
       map.put(s, value);
   }

   public int lookup(Expression s) {
       return map.get(s);
   }
}
/**
* 抽象表达式(Expression)角色
*/
public interface Expression {
   int interpret(Context context);
}
/**
* 终结符表达式(TerminalExpression)角色
*/
public class TerminalExpression implements Expression {

   private String variable;

   public TerminalExpression(String variable) {
       this.variable = variable;
   }

   @Override
   public int interpret(Context context) {
       return context.lookup(this);
   }
}
/**
* 非终结符表达式(NonterminalExpression)角色
*/
public class MinusExpression implements Expression {
   private Expression expression1;
   private Expression expression2;

   public MinusExpression(Expression expression1, Expression expression2) {
       this.expression1 = expression1;
       this.expression2 = expression2;
   }

   @Override
   public int interpret(Context context) {
       return this.expression1.interpret(context) - this.expression2.interpret(context);
   }
}
/**
* 非终结符表达式(NonterminalExpression)角色
*/
public class AddExpression implements Expression {
   private Expression expression1, expression2;

   public AddExpression(Expression expression1, Expression expression2) {
       this.expression1 = expression1;
       this.expression2 = expression2;
   }

   @Override
   public int interpret(Context context) {
       return this.expression1.interpret(context) + this.expression2.interpret(context);
   }

}
/**
* 客户端角色
*/
public class Client {
   public static void main(String[] args) {
       Context context = new Context();
       TerminalExpression a = new TerminalExpression("a");
       TerminalExpression b = new TerminalExpression("b");
       TerminalExpression c = new TerminalExpression("c");
       context.add(a, 4);
       context.add(b, 8);
       context.add(c, 2);
       System.out.println(new AddExpression(a, b).interpret(context));
       System.out.println(new MinusExpression(b, c).interpret(context));
   }
}

执行结果图