解释器模式是类的行为模式。
给定一个语言后，解释器模式可以定义出其文法的一种表示，
并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。
语言、解释器和浏览器
解释器模式只描述解释器是怎么工作的，并不指名怎样在运行时创建新的解释器。
虽然广义的将，解释器不一定要有一个浏览器，但是使用浏览器仍然是最常见的建立解释器的办法。
一个浏览器可以从一个文件或命令行读入文字性命令，并创建解释器。
浏览器的工作就是将一个文字性语言翻译成为等效的解释器语言。因此，解释器往往需要浏览器。
解释器模式的结构
模式涉及的角色：
1. 抽象表达式角色（Expression）: 声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个 interpret()方法，称作解释操作。
2. 终结符表达式角色（Terminal Expression）： 这是一个具体角色。
- 实现了抽象表达式角色所要求的接口，主要是一个 interpret() 方法；
- 文法中的每一个终结符都有一个具体终结表达式与之对应。
3. 非终结符表达式角色（Nonterminal Expression）: 这是一个具体角色。
- 文法中的每一条规则 R = R1R2...Rn都需要一个具体的非终结表达式类；
- 对每一个R1R2...Rn中的符号都持有一个静态类型为Expression的实例变量；
- 实现解释操作，即 interpret() 方法。解释操作以递归方式调用上面所提到的代表 R1R2...Rn中的各个符号的实例变量。
4. 客户端角色（Client）: 代表模式的客户端有以下功能：
- 建造一个抽象语法树（AST或者Abstract Syntax Tree）;
- 调用解释操作 interpret()。
在一般情况下，模式还需要一个环境角色。
5. 环境角色（Context）: 提供解释器之外的一些全局信息，比如变量的真实量值等。
一个示意性实现
这里给出一个最简单的文法和对应的解释器模式的实现，这个简单文法如下：
抽象语法树（AST）的每一个节点都代表一个语句，而在每一个节点上都可以执行解释方法。
解释器模式系统的结构图：
首先，抽象表达式角色（Expression）声明了由三个方法组成的接口，其中最重要的就是解释操作方法 interpret() 方法。
其次是终结表达式角色：Constant, Variable。
再次是非终结表达式角色：And, Or, Not
And非终结表达式代表一个二元运算，运算的文法是R = R1R2,或者 Expression ‘And’ Expression,
因此，它会有两个合成的关系指向Expression类。
Or非终结表达式也是一个二元运算，运算的文法是R=R1R2,或者 Expression 'Or' Expression,
因此，它也有两个合成关系指向Expression类。
Not非终结表达式代表一个一元运算，文法 R=R1,或者 ‘Not’ Expression,因此它只有一个合成关系指向Expression类。
源码：
抽象角色Expression
public abstract class Expression { public abstract boolean interpret(Context ctx); public abstract boolean equals(Object o); public abstract int hashCode(); public abstract String toString(); }
Constant类
public class Constant extends Expression { private boolean value; public Constant(boolean value){ this.value = value; } /** * 解释操作 */ @Override public boolean interpret(Context ctx) { return value; } /** * 检验两个表达式在结构上是否相同 */ @Override public boolean equals(Object o) { if(o!=null && o instanceof Constant){ return this.value == ((Constant)o).value; } return false; } /** * 返回表达式的hash code */ @Override public int hashCode() { return (this.toString()).hashCode(); } /** * 将表达式转换成字符串 */ @Override public String toString() { return new Boolean(value).toString(); } }
Variable类
public class Variable extends Expression { private String name; public Variable(String name) { this.name = name; } /** * 解释操作 */ public boolean interpret(Context ctx) { return ctx.lookup(this); } @Override public boolean equals(Object o) { if(o!=null && o instanceof Variable) { return this.name.equals(((Variable)o).name); } return false; } @Override public int hashCode() { // TODO Auto-generated method stub return (this.toString()).hashCode(); } @Override public String toString() { // TODO Auto-generated method stub return name; } }
And类
public class And extends Expression { private Expression left,right; public And(Expression left,Expression right){ this.left = left; this.right = right; } /** * 解释操作 */ @Override public boolean interpret(Context ctx) { // TODO Auto-generated method stub return left.interpret(ctx) && right.interpret(ctx); } @Override public boolean equals(Object o) { if(o!=null && o instanceof And) { return this.left.equals(((And)o).left) && this.right.equals(((And)o).right); } return false; } @Override public int hashCode() { // TODO Auto-generated method stub return (this.toString()).hashCode(); } @Override public String toString() { // TODO Auto-generated method stub return "(" + left.toString() + " AND" + right.toString() + ")"; } }
Or类
public class Or extends Expression { private Expression left,right; public Or(Expression left,Expression right){ this.left = left; this.right = right; } @Override public boolean interpret(Context ctx) { // TODO Auto-generated method stub return left.interpret(ctx) || right.interpret(ctx); } @Override public boolean equals(Object o) { if(o!=null && o instanceof Or) { return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right); } return false; } @Override public int hashCode() { // TODO Auto-generated method stub return (this.toString()).hashCode(); } @Override public String toString() { // TODO Auto-generated method stub return "(" + left.toString() + " OR " + right.toString() + ")"; } }
Not类
public class Not extends Expression { private Expression exp; public Not(Expression exp) { this.exp = exp; } @Override public boolean interpret(Context ctx) { // TODO Auto-generated method stub return !exp.interpret(ctx); } @Override public boolean equals(Object o) { if(o!=null && o instanceof Not) { return this.exp.equals(((Not)o).exp); } return false; } @Override public int hashCode() { // TODO Auto-generated method stub return (this.toString()).hashCode(); } @Override public String toString() { // TODO Auto-generated method stub return "(Not "+exp.toString()+")"; } }
Context类
public class Context { private HashMap map = new HashMap(); public void assign(Variable var, boolean value) { map.put(var, new Boolean(value)); } public boolean lookup(Variable var) throws IllegalArgumentException { Boolean value= (Boolean)map.get(var); if(value==null){ throw new IllegalArgumentException(); } return value.booleanValue(); } }
Client类
public class Client { private static Context ctx; private static Expression exp; public static void main(String[] args){ ctx = new Context(); Variable x=new Variable("x"); Variable y = new Variable("y"); Constant c = new Constant(true); ctx.assign(x, false); ctx.assign(y, true); exp = new Or(new And(c,x), new And(y,new Not(x))); System.out.println("x="+x.interpret(ctx)); System.out.println("y="+y.interpret(ctx)); System.out.println(exp.toString() + "="+ exp.interpret(ctx)); } }
客户端定义的布尔表达式是：（true And x）Or (y And (Not x))
运行结果：
x=false
y=true
((true ANDx) OR (y AND(Not x)))=true
这就是解释器对这个布尔表达式解释的结果。
解释器模式适用于以下情况：
1. 系统有一个简单的语言可供解释。
2. 一些重复发生的问题可以用这种简单的语言表达。
3. 效率不是主要的考虑。