简单的介绍一下Java设计模式：解释器模式

目录

• 定义
• 意图
• 主要解决问题
• 优缺点
• 结构
• 示例
• 适用情况

定义

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

意图

给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子

主要解决问题

对于一些固定文法构建一个解释句子的解释器

优缺点

优点：

• 扩展性好，灵活
• 增加了新的解释表达式的方式
• 易于实现简单的文法

缺点：

• 使用场景较少
• 对于复杂的文法比较难以维护
• 会引起类膨胀
• 采用递归调用方法，效率低

结构

涉及的角色：

• 抽象表达式（Expression）角色：声明一个所有的具体表达式角色都需要实现的抽象接口，这个接口主要是一个interpret方法，称作解释操作
• 终结符表达式（TerminalExpression）角色：这是一个具体角色
  • 实现了抽象表达式角色要求的接口，主要是一个interpret方法
  • 文法中的每一个终结符都有一个具体终结表达式与之相对应
• 非终结符表达式（NonterminalExpression）角色：这是一个具体角色
  • 文法中的每一条规则R=R1R2...Rn都需要一个具体的非终结符表达式类
  • 对每一个R=R1R2...Rn中的符号都持有一个静态类型为Expression的实例变量
  • 实现解释操作interpret方法，解释操作以递归方式调用上面所提到的代表R1R2...Rn中的各个符号的实例变量
• 客户端（Client）角色：建造一个抽象语法树，调用解释操作
• 环境（Context）角色：提供解释器之外的一些全局信息，比如变量的真实量值等

示例

抽象表达式角色：

/**
 * 这个抽象类代表终结类和非终结类的抽象化
 */
public 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对象代表一个布尔常量

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

    /** 返回表达式的hashCode */
    @Override
    public int hashCode() {
        return (this.toString()).hashCode();
    }

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

一个Variable对象代表一个有名变量

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

    /** 检验两个表达式在结构上是否相同 */
    @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;
    }
}

非终结表达式角色：



表示由两个布尔表达式通过逻辑与操作给出一个新的布尔表达式的操作：

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

    /** 检验两个表达式在结构上是否相同 */
    @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;
    }

    /** 返回表达式的hashCode */
    @Override
    public int hashCode() {
        return (this.toString()).hashCode();
    }

    /** 将表达式转换为字符串 */
    @Override
    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;
    }

    /** 解释操作 */
    @Override
    public boolean interpret(Context ctx) {
        return left.interpret(ctx) || right.interpret(ctx);
    }

    /** 检验两个表达式在结构上是否相同 */
    @Override
    public boolean equals(Object o) {
        if (o != null && o instanceof Or) {
            return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
        }
        return false;
    }

    /** 返回表达式的hashCode */
    @Override
    public int hashCode() {
        return (this.toString()).hashCode();
    }

    /** 将表达式转换为字符串 */
    @Override
    public String toString() {
        return "(" + left.toString() + " OR " + right.toString() + ")";
    }
}

表示由一个布尔表达式通过逻辑非操作给出一个新的布尔表达式的操作：

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

    /** 返回表达式的hashCode */
    @Override
    public int hashCode() {
        return (this.toString()).hashCode();
    }

    /** 将表达式转换为字符串 */
    @Override
    public String toString() {
        return "(Not " + exp.toString() + ")";
    }
}

环境类定义出从变量到布尔值的一个映射：

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

适用情况

• 系统有一个简单的语言可供解释
• 一些重复发生的问题可以用这种简单的语言表达
• 效率不是主要考虑的问题