行为模式---之--解释器模式

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

 

如果某一类问题一再地发生的话，那么一个意义的做法就是将此类问题的各个实例表达为一个简单语言中的语句。这样就可以建造一个解释器，通过解释这些语句达到解决问题的目的。

 

模式所涉及的角色有：

1.抽象表达式（Expression）角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作

2.终结符表达（Terminal Expression）表达式角色：这是一个具体角色，它实现了抽象表达式角色所要求的接口，主要是一个interpret（）方法。文法中的每一个终结符都有一个具体终结表达式与之相对应。

3.非终结符表达式（Nonterminal Expression）角色：这是一个具体角色。

文法中的每一条规则R=R1R2..Rn都需要一个具体的非终结符表达式类。对每一个R1R2..Rn中的符号都持有一个静态类型为Expression的实例变量。实现解释操作，即interpret()方法。解释操作以递归方式调用上面所提到的代表R1R2..Rn中的各个符号的实例变量。

4.客户端（Client）角色：代表模式的客户端它有以下功能：

建造一个抽象语法树

调用解释操作（interpret()）

在一般情况下，模式还需要一个环境角色：

5.环境（Context）角色：提供解释器之外的一些全局信息，比如变量的真实量值

 

这个例子模仿Java语言中对布尔表达式进行操作和求值。

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

//抽象角色Expression
/*
 * 这个抽象类代表终结类和非终结类的抽象化
 * 其中终结类和非终结类来自下面的文法
 * Expression ::=
 *                 Expression AND Expression
 *                 |Expression OR Expression
 *                 |NOT Expression
 *                 |Variable
 *                 |Constant
 * Variable ::=...//可以打印出的非空白字符串
 * Contant ::="true"|"false"
 */
abstract class Expression{
    //以环境类为准，本方法解释给定的任何一个表达式
    public abstract boolean interpret(Context ctx);
    //检验两个表达式在结构上是否相同
    public abstract boolean equals(Object o);
    //返回表达式的hashcode
    public abstract int hashCode();
    //将表达式转换成字符串
    public abstract String toString();
}

//Constant类,通过构造子传入一个布尔常量，得到一个包装了这个布尔常量的对象，new Constant(true)
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;
    }

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

    @Override
    public String toString() {
        return new Boolean(value).toString();
    }
    
}
//Variable类 使用时将变量名传入构造子中，如new Variable("x")就声明了一个名字为x的变量
class Variable extends Expression{
    private String name;
    
    public Variable(String name){
        this.name = name;
    }
    //解释操作
    @Override
    public boolean interpret(Context ctx) {
        try {
            return ctx.lookup(this);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean equals(Object o) {
        if(o!=null&&o instanceof Variable){
            return this.name.equals(((Variable)o).name);
        }
        return false;
    }
    
    //返回hashcode
    @Override
    public int hashCode() {
        return (this.toString()).hashCode();
    }
    
    //将表达式转换成字符串
    @Override
    public String toString() {
        return name;
    }
}
//And类 new And(x,y)代表x And y
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) {
        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() {
        return this.toString().hashCode();
    }
    //将表达式转换成字符串
    @Override
    public String toString() {
        return "("+left.toString()+"AND"+right.toString()+")";
    }
    
}
//Or类
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) {
        return left.interpret(ctx)&&right.interpret(ctx);
    }

    @Override
    public boolean equals(Object o) {
        if(o!=null&&o instanceof And){
            return this.left.equals(((Or)o).left)&&this.right.equals(((Or)o).right);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.toString().hashCode();
    }
    //将表达式转换成字符串
    @Override
    public String toString() {
        return "("+left.toString()+"OR"+right.toString()+")";
    }
}
//Not类
class Not extends Expression{
    private Expression exp;
    public Not(Expression exp){
        this.exp = exp;
    }
    @Override
    public boolean interpret(Context ctx) {
        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() {
        return this.toString().hashCode();
    }
    @Override
    public String toString() {
        return "(Not" + exp.toString() +")";
    }
}

//Context
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 Exception{
        Boolean value = (Boolean)map.get(var);
        if(value ==null){
            throw new Exception();
        }
        return value.booleanValue();
    }
}

解释器模式适用于以下情况：

1.系统有一个简单的语言可供解释

2.一些重复发生的问题可以用这种简单的语言表达

3.效率不是主要考虑