Interpreter Expression 解释器模式

简介

Interpreter模式也叫解释器模式，是由GoF提出的23种设计模式中的一种。Interpreter是行为模式之一，它是一种特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。



应用环境：
如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。而且当【文法简单】、【效率不是关键问题】的时候效果最好。
当有一个语言需要【解释执行】，并且你可将该语言中的句子表示为一个【抽象语法树】，可以使用解释器模式。



角色：



抽象表达式角色(AbstractExpression): 声明一个抽象的解释操作，这个接口为所有具体表达式角色都要实现的
终结符表达式角色(TerminalExpression): 实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例对应不同的终结符
非终结符表达式角色(NonterminalExpression): 文法中的每条规则对应于一个非终结表达式，非终结表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式
环境角色(Context): 包含解释器之外的一些全局信息






优点：

解释器是一个简单语法分析工具，它最显著的优点就是【扩展性】，修改语法规则只要修改相应的【非终结符表达式】就可以了，若扩展语法，则只要增加【非终结符类】就可以了。

缺点：

解释器模式会引起【类膨胀】，每个语法都要产生一个非终结符表达式，语法规则比较复杂时，可能产生大量的类文件，难以维护
解释器模式采用【递归调用】方法，它导致调试非常复杂
解释器由于使用了大量的循环和递归，所以当用于解析复杂、冗长的语法时，【效率】是难以忍受的

注意事项：

尽量不要在重要模块中使用解释器模式，因为维护困难。在项目中，可以使用shell,JRuby,Groovy等脚本语言来代替解释器模式。




作用：用一组类代表某一规则
类图：四则运算


这个模式通常定义了一个语言的语法，然后解析相应语法的语句。
java.util.Pattern
java.text.Normalizer
java.text.Format

经典案例

public class Test2 {
    public static void main(String[] args) {
        //计算(7*8)/(7-8+2)的值
        Context context = new Context();
        context.addValue("a", 7);
        context.addValue("b", 8);
        context.addValue("c", 2);

        AbstractExpression multiplyValue = new MultiplyNTExpression(new TerminalExpression(context.getValue("a")), new TerminalExpression(context.getValue("b")));//a*b
        AbstractExpression subtractValue = new SubtractNTExpression(new TerminalExpression(context.getValue("a")),    new TerminalExpression(context.getValue("b")));//a-b
        AbstractExpression addValue = new AddNTExpression(subtractValue, new TerminalExpression(context.getValue("c")));//(a-b)+c
        AbstractExpression divisionValue = new DivisionNTExpression(multiplyValue, addValue);//(a*b)/(a-b+c)

        System.out.println(divisionValue.interpreter(context));
    }
}



class Context {
    private Map<String, Integer> valueMap = new HashMap<String, Integer>();

    public void addValue(String key, int value) {
        valueMap.put(key, value);
    }

    public int getValue(String key) {
        return valueMap.get(key);
    }
}



/**抽象表达式角色(AbstractExpression): 声明一个抽象的解释操作，这个接口为所有具体表达式角色都要实现的*/
abstract class AbstractExpression {
    public abstract int interpreter(Context context);
}



/**终结符表达式角色(TerminalExpression): 实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例对应不同的终结符*/
class TerminalExpression extends AbstractExpression {//Terminal 终结符,末期的,晚期的。终结符就是语言中用到的基本元素，一般不能再被分解
    private int i;

    public TerminalExpression(int i) {
        this.i = i;
    }

    @Override
    public int interpreter(Context context) {//不进行任何操作
        return i;
    }
}



/**非终结符表达式角色(NonterminalExpression): 文法中的每条规则对应于一个非终结表达式，非终结表达式根据逻辑的复杂程度而增加*/
class AddNTExpression extends AbstractExpression {//Nonterminal 非终结符号，非末端
    private AbstractExpression left;
    private AbstractExpression right;

    public AddNTExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) + right.interpreter(context);//加法操作
    }
}

class SubtractNTExpression extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;

    public SubtractNTExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) - right.interpreter(context);//减法操作
    }
}

class MultiplyNTExpression extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;

    public MultiplyNTExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(Context context) {
        return left.interpreter(context) * right.interpreter(context);//乘法操作
    }
}

class DivisionNTExpression extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;

    public DivisionNTExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(Context context) {
        int value = right.interpreter(context);
        if (value != 0) return left.interpreter(context) / value;//除法操作
        return -1111;
    }

}

演示

public class Context {
    private Map<Variable, Boolean> map = new HashMap<Variable, Boolean>();

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

    public boolean lookup(Variable var) throws IllegalArgumentException {
        Boolean value = map.get(var);
        if (value == null) throw new IllegalArgumentException();
        return value.booleanValue();
    }

}



public abstract class Expression {
    /**以环境为准，本方法解释给定的任何一个表达式     */
    public abstract boolean interpret(Context ctx);

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



class Constant extends Expression {

    private boolean value;

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

    @Override
    public boolean equals(Object obj) {

        if (obj != null && obj instanceof Constant) {
            return this.value == ((Constant) obj).value;
        }
        return false;
    }

    @Override
    public boolean interpret(Context ctx) {

        return value;
    }

    @Override
    public String toString() {
        return new Boolean(value).toString();
    }

}

class Variable extends Expression {

    private String name;

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

    @Override
    public boolean equals(Object obj) {

        if (obj != null && obj instanceof Variable) {
            return this.name.equals(((Variable) obj).name);
        }
        return false;
    }

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

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

}



class And extends Expression {

    private Expression left, right;

    public And(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj != null && obj instanceof And) {
            return left.equals(((And) obj).left) && right.equals(((And) obj).right);
        }
        return false;
    }

    @Override
    public boolean interpret(Context ctx) {

        return left.interpret(ctx) && right.interpret(ctx);
    }

    @Override
    public String toString() {
        return "(" + left.toString() + " AND " + right.toString() + ")";
    }

}

class Or extends Expression {
    private Expression left, right;

    public Or(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj != null && obj instanceof Or) {
            return this.left.equals(((Or) obj).left) && this.right.equals(((Or) obj).right);
        }
        return false;
    }

    @Override
    public boolean interpret(Context ctx) {
        return left.interpret(ctx) || right.interpret(ctx);
    }

    @Override
    public String toString() {
        return "(" + left.toString() + " OR " + right.toString() + ")";
    }

}

class Not extends Expression {

    private Expression exp;

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

    @Override
    public boolean equals(Object obj) {
        if (obj != null && obj instanceof Not) {
            return exp.equals(((Not) obj).exp);
        }
        return false;
    }

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

    @Override
    public String toString() {
        return "(Not " + exp.toString() + ")";
    }


}



public class Test {
    public static void main(String[] args) {
        Context 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);    

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

    }

}

来自为知笔记(Wiz)

附件列表