六十二：解释器模式

在给定一种语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器，客户端可以使用这个解释器来解释这个语言中的句子.这样就可以建造一个解释器，通过解释这些语句达到解决问题的目的.例如依照一个匹配模式搜寻字符串便是一个常见的问题，与其为每一个匹配模式建造一个特定的算法，不如建造一个一般性的算法处理各种常规表达式，当接到一个指定的常规表达式时，系统使用一个解释器解释这个常规表达式，从而对字符串进行区配.现在要介绍的解释器模式将怎么样在有了一个简单的文法后使用模式设计解释这些语句，熟悉了这个模式之后，一个没有接收过形式语言(什么是形式语言)和编译器(看来读编译原理是必须的)的正规训练的设计师也可以自行设计一个简单的解释器!

一：语言，解释器和浏览器
解释器模式只描述解释器是怎么样工作的，并不指明怎么样在运行时创建新的解释器。虽然广义地讲，解释器不一定要有一个浏览器(Parser)，但是使用浏览器仍然是最常见的建立解释器的办法.一个浏览器可以从一个文件或命令行读入文字性命令，并创建解释器.
浏览器是一种能够识别文字并将文字按照一定规则进行分解以便进一步处理的对象。浏览器能够识别的字符叫做语言.通常建立的小型计算机语言是与环境无关的语言，也就是遵循一定的方法的文字模式。所谓文法，便是决定怎么样将语言元素组合起来的规则的集合。浏览器便是根据组合规则将字符串分解的.
抽象地讲，语言并不一定是以字符串的形式表达的，在解释器模式里面所提到的语言是指任何解释器能够解释的任何组合。在解释器模式中，需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则：每一个命令对象都有一个解释方法，代表对命令对象的解释.
命令对象的等级结构中的对象的任何排列组合都是一个语言，而浏览器的工作便是将一个文字性语言翻译成为等效的解释器语言，因此解释器往往需要浏览器

二：模式所涉及的角色
(A)抽象表达式(Expression)角色:声明一个所有的具体表达式角色都需要实现的抽象接口，这个接口主要是一个interpret()方法，称作解释操作.
(B)终结符表达式(TerminalExpression)角色：这是一个具体角色，实现了抽象表达式角色，文法中的每一个终结符都有一个具体终结表达式与之相对应.
(C)非终结表达式(NonterminalExpression)角色：文法中的每一条规则R=R1R2...Rn都需要一个具体的非终结符表达式类,对每一个R1R2....Rn中的符号都持有一个静态类型为Expression的实例变量，实现解释操作interpret，解释操作以递归方式调用上面所提到的代表R1R2....Rn中各个符号的实例变量
(D)客户端(Client)角色：代表模式的客户端有以下功能：建造一个抽象语法树，调用解释操作interpret
在一般情况下，模式还需要一个环境(Context)角色:提供解释器之外的一些全局信息，比如变量的真实值等.

三：一个示意性的实现
为了说明解释器模式的实现办法，这里给出一个最简单的文法和对应的解释器模式的实现--模拟Java语言中对布尔表达式进行操作和求值.
在这个语言中，终结符是布尔变量，也就是常量true和false，非终结符表达式包含运算符and,or和not等布尔表达式，这个简单的文法如下：
Expression ::=Constant|Variable|Or|And|Not
And ::=Expression 'AND' Expression
Or ::=Expression 'OR' Expression
Not ::=Expression 'Not' Expression
Variable ::=任何标识符
Constant ::='true'|'false'
源码如下：

引用

package cai.milenfan.basic.test;

/**
*这个抽象类代表终结类和非终结类的抽象化
*其中终结类和非终结类来自下面的文法:<br>
* <pre>
* BooleanExp ::=
* BooleanExp AND BooleanExp
* | BooleanExp OR BooleanExp
* | NOT BooleanExp
* | Variable
* | Constant
* Variable ::= ... // a string of printable, non-white space characters
* Contant ::= "true" | "false"
* </pre>
*/
public abstract class Expression {
    /**
     *以环境为准，本方法解释给定的任何一个表达式
     */
    public abstract boolean interpret(Context ctx);
    /**
     *检验两个表达式在结构上是否相同
     */
    public abstract boolean equals(Object o);
    /**
     *返回表达式的hash code
     */
    public abstract int hashCode();
    /**
     *将表达式转换成字符串
     */
    public abstract String toString();
}

package cai.milenfan.basic.test; 

public class Constant extends Expression { 
private boolean value; 
public Constant(boolean value) { 
this.value = value; 
} 
public boolean interpret(Context ctx) { 
return value; 
} 
public boolean equals(Object o) { 
if (o != null && o instanceof Constant) { 
return this.value == ((Constant) o).value; 
} 
return false; 
} 
public int hashCode() { 
return (this.toString()).hashCode(); 
} 
public String toString() { 
return new Boolean(value).toString(); 
} 
} 

package cai.milenfan.basic.test; 

public class Variable extends Expression { 
private String name; 
public Variable(String name) { 
this.name = name; 
} 
public boolean interpret(Context ctx) { 
return ctx.lookup(this); 
} 
public boolean equals(Object o) { 
if (o != null && o instanceof Variable) { 
return this.name.equals(((Variable) o).name); 
} 
return false; 
} 
public int hashCode() { 
return (this.toString()).hashCode(); 
} 
public String toString() { 
return name; 
} 
} 

package cai.milenfan.basic.test; 

public class And extends Expression { 
private Expression left, right; 
public And(Expression left, Expression right) { 
this.left = left; 
this.right = right; 
} 
public boolean interpret(Context ctx) { 
return left.interpret(ctx) && right.interpret(ctx); 
} 
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; 
} 
public int hashCode() { 
return (this.toString()).hashCode(); 
} 
public String toString() { 
return "(" + left.toString() + " AND " + right.toString() + ")"; 
} 
} 

package cai.milenfan.basic.test; 

public class Or extends Expression { 
private Expression left, right; 
public Or(Expression left, Expression right) { 
this.left = left; 
this.right = right; 
} 
public boolean interpret(Context ctx) { 
return left.interpret(ctx) || right.interpret(ctx); 
} 
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; 
} 
public int hashCode() { 
return (this.toString()).hashCode(); 
} 
public String toString() { 
return "(" + left.toString() + " OR " + right.toString() + ")"; 
} 
} 

package cai.milenfan.basic.test; 

public class Not extends Expression { 
private Expression exp; 
public Not(Expression exp) { 
this.exp = exp; 
} 
public boolean interpret(Context ctx) { 
return !exp.interpret(ctx); 
} 
public boolean equals(Object o) { 
if (o != null && o instanceof Not) { 
return this.exp.equals(((Not) o).exp); 
} 
return false; 
} 
public int hashCode() { 
return (this.toString()).hashCode(); 
} 
public String toString() { 
return " (Not " + exp.toString() + ")"; 
} 
} 

package cai.milenfan.basic.test; 

import java.util.HashMap; 

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(); 
} 
} 

package cai.milenfan.basic.test; 

import java.awt.Canvas; 

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)); 
} 
} 

深入学习请阅读编译原理.