设计模式~解释器

解释器模式是类的行为模式。

给定一个语言后,解释器模式可以定义出其文法的一种表示,

并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。

语言、解释器和浏览器

解释器模式只描述解释器是怎么工作的,并不指名怎样在运行时创建新的解释器。

虽然广义的将,解释器不一定要有一个浏览器,但是使用浏览器仍然是最常见的建立解释器的办法。

一个浏览器可以从一个文件或命令行读入文字性命令,并创建解释器。

浏览器的工作就是将一个文字性语言翻译成为等效的解释器语言。因此,解释器往往需要浏览器。

解释器模式的结构

 

 模式涉及的角色:

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

2. 终结符表达式角色(Terminal Expression): 这是一个具体角色。

  • 实现了抽象表达式角色所要求的接口,主要是一个 interpret() 方法;
  • 文法中的每一个终结符都有一个具体终结表达式与之对应。

3. 非终结符表达式角色(Nonterminal Expression): 这是一个具体角色。

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

4. 客户端角色(Client): 代表模式的客户端有以下功能:

  • 建造一个抽象语法树(AST或者Abstract Syntax Tree);
  • 调用解释操作 interpret()。

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

5. 环境角色(Context): 提供解释器之外的一些全局信息,比如变量的真实量值等。

一个示意性实现

这里给出一个最简单的文法和对应的解释器模式的实现,这个简单文法如下:

 抽象语法树(AST)的每一个节点都代表一个语句,而在每一个节点上都可以执行解释方法。

解释器模式系统的结构图:

首先,抽象表达式角色(Expression)声明了由三个方法组成的接口,其中最重要的就是解释操作方法 interpret() 方法。

其次是终结表达式角色:Constant, Variable。

再次是非终结表达式角色:And, Or, Not

And非终结表达式代表一个二元运算,运算的文法是R = R1R2,或者 Expression ‘And’ Expression,

因此,它会有两个合成的关系指向Expression类。

Or非终结表达式也是一个二元运算,运算的文法是R=R1R2,或者 Expression 'Or' Expression,

因此,它也有两个合成关系指向Expression类。

Not非终结表达式代表一个一元运算,文法 R=R1,或者 ‘Not’ Expression,因此它只有一个合成关系指向Expression类。

源码:

 抽象角色Expression

public abstract class Expression {

    public abstract boolean interpret(Context ctx);
    
    public abstract boolean equals(Object o);
    
    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;
    }

    /**
     * 返回表达式的hash code
     */
    @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;
    }
    /**
     * 解释操作
     */
    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;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return (this.toString()).hashCode();
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return name;
    }

}

And类

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) {
        // TODO Auto-generated method stub
        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() {
        // TODO Auto-generated method stub
        return (this.toString()).hashCode();
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "(" + left.toString()
                + " AND" 
                + right.toString() + ")";
    }

}

Or类

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) {
        // TODO Auto-generated method stub
        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;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return (this.toString()).hashCode();
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "(" + left.toString()
                + " OR "
                + right.toString() + ")";
    }

}

Not类

public class Not extends Expression {

    private Expression exp;
    public Not(Expression exp)
    {
        this.exp = exp;
    }
    
    @Override
    public boolean interpret(Context ctx) {
        // TODO Auto-generated method stub
        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() {
        // TODO Auto-generated method stub
        return (this.toString()).hashCode();
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "(Not "+exp.toString()+")";
    }

}

Context类

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

Client类

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

客户端定义的布尔表达式是:(true And x)Or (y And (Not x))

运行结果:

x=false
y=true
((true ANDx) OR (y AND(Not x)))=true

这就是解释器对这个布尔表达式解释的结果。

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

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

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

3. 效率不是主要的考虑。

 

posted @ 2020-10-07 09:13  Vincent-yuan  阅读(182)  评论(0编辑  收藏  举报