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

概述

定义：定义语言的文法，并且建立一个解释器来解释该语言中的句子

适用场景：

可以将一个需要解释执行的语言中的句子表示为一个抽象语法树

一些重复出现的问题可以用一种简单的语言来进行表达

一个简单语法需要解释的场景

实现

// 表达式接口
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

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