解释器（Interpreter）模式【行为模式第八篇】

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

一、解释器模式所涉及的角色
1、抽象表达式角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
2、终结符表达式角色：这是一个具体角色。
（1）实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；
（2）文法中的每一个终结符都有一个具体终结表达式与之相对应。
3、非终结符表达式角色：这是一个具体角色。
（1）文法中的每一条规则 R=R1R2.....Rn 都需要一个具体的非终结符表达式类；
（2）对每一个 R1R2.....Rn 中的符号都持有一个静态类型为Expression的实例变量。
（3）实现解释操作，即 interpret()方法。解释操作以递归方式调用上面所提到的代表 R1R2.....Rn 中的各个符号的实
例变量
4、客户端角色：代表模式的客户端它有以下功能
（1）建造一个抽象语法树（AST或者Abstract Syntax Tree）
（2）调用解释操作interpret()。
5、环境角色：（在一般情况下，模式还需要一个环境角色）提供解释器之外的一些全局信息，比如变量的真实量值等。

（抽象语法树的每一个节点都代表一个语句，而在每一个节点上都可以执行解释方法。这个解释方法的执行就代表这个语句被解释。
由于每一个语句都代表对一个问题实例的解答。）

 //抽象角色Expression
		  /*
		  	这个抽象类代表终结类和非终结类的抽象化
		  	其中终结类和非终结类来自下面的文法
		  	Expression ::=
		  			Expression AND Expression
		  			| Expression OR Expression
		  			| NOT Expression
		  			| Variable
		  			| Constant
		  	Variable ::= ....//可以打印出的非空白字符串
		  	Constant ::= "true" | "false"
		  */

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

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

		  	//返回表达式的hash code
		  	public int hashCode(){
		  		return (this.toString()).hashCode();
		  	}

		  	//将表达式转换成字符串
		  	public String toString(){
		  		return new Boolean(value).toString();
		  	}
		  }

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

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

		  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(((And)o).left) &&
		  				this.right.equals(((And)o).right);
		  		}
		  		return false;
		  	}

		  	public int hashCode(){
		  		return (this.toString()).hashCode();
		  	}

		  	public String toString(){
		  		return "(" + left.toString() + "OR" + right.toString() + ")";
		  	}
		  }

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

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

		  //客户端
		  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));
		  	}
		  }

二、解释器模式适用于以下的情况：
（1）系统有一个简单的语言可供解释
（2）一些重复发生的问题可以用这种简单的语言表达
（3）效率不是主要的考虑。