【每日一记】设计模式——解释器模式

概述

• 定义：定义语言的文法，并且建立一个解释器来解释该语言中的句子
• 适用场景：
  
  1. 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
  2. 一些重复出现的问题可以用一种简单的语言来进行表达
  3. 一个简单语法需要解释的场景

实现

// 表达式接口
public interface Expression {
    boolean interpret(Context ctx);
}

// 与
public class And implements Expression {
    private Expression left;
    private Expression 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 String toString() {
        return "(" + left.toString() + " && " + right.toString() + ")";
    }

}

// 或
public class Or implements Expression {
    private Expression left;
    private Expression 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 String toString() {
        return "(" + left.toString() + " || " + right.toString() + ")";
    }

}

// 非
public class Not implements Expression {
    private Expression ex;

    public Not(Expression ex) {
        this.ex = ex;
    }

    @Override
    public boolean interpret(Context ctx) {
        return !ex.interpret(ctx);
    }

    @Override
    public String toString() {
        return "!(" + ex + ")";
    }

}

// 变量
public class Variable implements Expression {
    private String name;

    public Variable(String name) {
        this.name = name;
    }

    @Override
    public boolean interpret(Context ctx) {
        return ctx.lookup(this);
    }

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

    @Override
    public boolean equals(Object o) {
        if (o != null && o instanceof Variable) {
            return this.name.equals(((Variable) o).name);
        }
        return false;
    }

    @Override
    public String toString() {
        return name;
    }

}

// 常量
public class Constant implements Expression {
    private boolean b;

    public Constant(boolean b) {
        this.b = b;
    }

    @Override
    public boolean interpret(Context ctx) {
        return b;
    }

    @Override
    public String toString() {
        return String.valueOf(b);
    }

}

// 上下文，存储变量
public class Context {
    private Map<Variable, Boolean> m = new HashMap<>();

    public void assign(Variable var, boolean value) {
        m.put(var, new Boolean(value));
    }

    public boolean lookup(Variable var) {
        return m.get(var);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) throws Exception {
        Context ctx = new Context();
        Variable a = new Variable("a");
        Variable b = new Variable("b");
        ctx.assign(a, true);
        ctx.assign(b, false);
        Constant c1 = new Constant(true);
        Constant c2 = new Constant(false);
        Expression ex = new Or(new And(a, new And(c2, b)), new Not(c1));
        System.out.println(ex);
        System.out.println(ex.interpret(ctx));
    }
}

输出结果
((a && (false && b)) || !(true))
false

解释器模式带来了良好的扩展性，修改语法规则只要修改相应的非终结符表达式，若扩展语法，则只需增加非终结符类，但是由于大量的循环和递归可能会引发一定的效率问题