解释器模式是类的行为模式。
给定一个语言后，解释器模式可以定义出其文法的一种表示，
并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。
语言、解释器和浏览器
解释器模式只描述解释器是怎么工作的，并不指名怎样在运行时创建新的解释器。
虽然广义的将，解释器不一定要有一个浏览器，但是使用浏览器仍然是最常见的建立解释器的办法。
一个浏览器可以从一个文件或命令行读入文字性命令，并创建解释器。
浏览器的工作就是将一个文字性语言翻译成为等效的解释器语言。因此，解释器往往需要浏览器。
解释器模式的结构
模式涉及的角色：
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
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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类
代码语言：javascript复制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. 效率不是主要的考虑。
