解释器模式

      解释器模式:给定一个语言, 定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
由定义来看,解释器模式就是一个不常用的模式,但是学习一下也没有坏处.
我第一次听到解释器模式的时候想到的东西就是命令行(CMD)解释器,这就是典型的望文生义.但是解释器模式也没有想象中的复杂, 先举两个例子来对解释器模式建立一个大体的印象.第一个是: 早期的手机中都有一个铃声编辑器, 你可以自己输入1 2 3 4 5 6 7 等来编辑一个铃声,手机中一定有一个程序来读取你编辑的文件,然后按照一定的发音规则来播放它们. 那么这个播放程序就是一个解释器, 输入的乐谱就是就是音乐的文法表示. 另一个例子: 银行经常要用复杂而变化的模型来计算数据, 比如(1+r)^n*c, (r=Rate, n=Years, c=Capital)这个公示就是计算一笔存款存n年之后的的总额.如果说这个公式比较固定不变, 那么我们写一个函数/方法就搞定了, 但是如果随着银行产品种类的增多, 业务种类的增多, 公式将会多种多样,已经不再可能用函数来应对需求的变化,于是可以有一个公式编辑器,程序通过解析公式,然后给公式的参数赋值就可以应对需求. 那么这个程序就是一个解释器.

      以一个简单的模型公式为例实现一个解释， 要求指定参与运算的元素(如a,b,c),然后输入公式即可计算出结果. 为了演示的方便,只考虑加减法.如果一个系统中参与运算的元素为a,b,c,d ... 当然这些元素背后对应的物理意义或者业务意义我们就不细追究. 客户端指定一个公式,如 a+b-c, a+b+c-d, 就可以计算出结果.

      package designpattern.intpreter;  
import java.util.HashMap;  
 
public interface Expression {  
    public int interprete(HashMap<String,Integer> var);  
}  
//////////////////////////  
package designpattern.intpreter;  
 
import java.util.HashMap;  
 
public class VarExpression implements Expression{  
    private String key;  
    public VarExpression(String key){  
        this.key = key;  
    }  
      
    public int interprete(HashMap<String,Integer> var) {  
        return (Integer)var.get(this.key);  
    }  
}  
////////////////////////////  
package designpattern.intpreter;  
 
public abstract class SymbolExpression implements Expression {  
    protected Expression left;  
    protected Expression right;  
 
    // 所有的解析公式都应只关心自己左右两个表达式的结果  
    public SymbolExpression(Expression left, Expression right) {  
        this.left = left;  
        this.right = right;  
    }  
}  
//////////////////////////////////  
package designpattern.intpreter;  
 
import java.util.HashMap;  
 
public class AddExpression extends SymbolExpression {  
    public AddExpression(Expression _left, Expression _right) {  
        super(_left, _right);  
    }  
 
    // 把左右两个表达式运算的结果加起来  
    public int interprete(HashMap<String, Integer> var) {  
        return super.left.interprete(var) + super.right.interprete(var);  
    }  
}  
///////////////////////////////////  
package designpattern.intpreter;  
 
import java.util.HashMap;  
 
public class SubExpression extends SymbolExpression {  
    public SubExpression(Expression _left, Expression _right) {  
        super(_left, _right);  
    }  
 
    // 左右两个表达式相减  
    public int interprete(HashMap<String, Integer> var) {  
        return super.left.interprete(var) - super.right.interprete(var);  
    }  
 
}  
////////////////////////////  
package designpattern.intpreter;  
import java.util.HashMap;  
import java.util.Stack;  
 
public class Calculator {  
    private Expression expression;  
    public Calculator(String expStr) {  
        // 定义一个堆栈，安排运算的先后顺序  
        Stack<Expression> stack = new Stack<Expression>();  
        // 表达式拆分为字符数组  
        char[] charArray = expStr.toCharArray();  
        // 运算  
        Expression left = null;  
        Expression right = null;  
        for (int i = 0; i < charArray.length; i++) {  
            switch (charArray[i]) {  
            case '+': // 加法  
                // 加法结果放到堆栈中  
                left = stack.pop();  
                right = new VarExpression(String.valueOf(charArray[++i]));  
                stack.push(new AddExpression(left, right));  
                break;  
            case '-':  
                left = stack.pop();  
                right = new VarExpression(String.valueOf(charArray[++i]));  
                stack.push(new SubExpression(left, right));  
                break;  
            default: // 公式中的变量  
                stack.push(new VarExpression(String.valueOf(charArray[i])));  
            }  
        }  
        // 把运算结果抛出来  
        this.expression = stack.pop();  
    }  
 
    // 开始运算  
    public int run(HashMap<String, Integer> var) {  
        return this.expression.interprete(var);  
    }  
}  
//////////////////////////////  
//测试用例  
package designpattern.intpreter;  
import java.util.HashMap;  
 
public class Client {  
    public static void main(String[] args){  
        //构造运算元素的值列表  
        HashMap<String, Integer> ctx = new HashMap<String, Integer>();  
        ctx.put("a", 10);  
        ctx.put("b", 20);  
        ctx.put("c", 30);  
        ctx.put("d", 40);  
        ctx.put("e", 50);  
        ctx.put("f", 60);  
        Calculator calc = new Calculator("a+b-c");  
        int result = calc.run(ctx);  
        System.out.println("Result of a+b-c: " + result);  
        calc = new Calculator("d-a-b+c");  
        result = calc.run(ctx);  
        System.out.println("Result of d-a-b+c: " + result);  
    }  
}