解释器模式

解释器模式（Interpreter Pattern）属于行为型模式。意图是给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

一个简单的demo：

当前的环境，用于存储当前环境下自定义变量的真假

public class Context {

    private Map<Variable, Boolean> map = new HashMap<>();

    // 设置自定义变量的真假
    public void assign(Variable var, boolean value) {
        map.put(var, new Boolean(value));
    }

    // 查询自定义变量的真假
    public boolean lookup(Variable var){
        Boolean value = map.get(var);
        if (value == null){
            throw  new IllegalArgumentException();
        }
        return value.booleanValue();
    }
}

以环境为准，解释一个表达式的真假

public abstract class Expression {
    public abstract boolean interpret(Context ctx);

}

定义变量

public class Variable extends Expression {
    private String name;
    public Variable(String name){
        this.name = name;
    }
    @Override
    public boolean interpret(Context ctx) {
        return ctx.lookup(this);
    }

}

定义And和Or表达式

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) {
        return left.interpret(ctx) && right.interpret(ctx);
    }

}

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) {
        return left.interpret(ctx) || right.interpret(ctx);
    }
}

调用

Context context = new Context();
Variable x = new Variable("x");
Variable y = new Variable("y");
Variable z = new Variable("z");
context.assign(x, false);
context.assign(y, true);
context.assign(z, false);

Expression exp = new Or(new And(x, y), z);
System.out.println(exp.interpret(context));

输出结果

false