解释器模式

public abstract class Expression {

    /* 解析公式和数值。当中var中的key值是公式中的參数，value值是详细的数字  */
    public abstract int interpreter(HashMap<String, Integer> var);

}

public abstract class SymbolExpression extends Expression{

    protected Expression left;
    protected Expression right;

    /* 全部的解析公式都应仅仅关心自己左右两个表达式的结果 */
    public SymbolExpression(Expression _left,Expression _right){
        this.left = _left;
        this.right= _right;
    }

}

/**
 * 减法解析器
 * @author Administrator
 */
public class SubExpression extends SymbolExpression{

    public SubExpression(Expression _left, Expression _right) {
        super(_left, _right);
    }

    /* 左右两个表达式相减 */
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }

}

/**
 *
 * 加法解析器
 * @author Administrator
 */
public class AddExpression extends SymbolExpression{

    public AddExpression(Expression _left,Expression _right){
        super(_left, _right);
    }

    /* 把左右两个表达式运算的结果加起来  */
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

/**
 * 封装解析器
 * @author Administrator
 */
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 TerminalExpression(String.valueOf(charArray[++i]));
                stack.push(new AddExpression(left, right));
                break;
            case ‘-‘ : //加法
                left = stack.pop();
                right =  new TerminalExpression(String.valueOf(charArray[++i]));
                stack.push(new SubExpression(left, right));
                break;
            default: //公式中的变量
                stack.push(new TerminalExpression(String.valueOf(charArray[i])));
                break;
            }
        }
        /* 把运算结果抛出来  */
        this.expression = stack.pop();
    }
    /**
     * 開始运算
     * @param var
     */
    public int run(HashMap<String, Integer> var){
        return this.expression.interpreter(var);
    }
}

public class TerminalExpression extends Expression{

    private String key;

    public TerminalExpression(String _key){
        this.key = _key;
    }

    /* 通常终结符表达式仅仅有一个，可是有多个对象 */
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }

}

/**
 * 解释器模式
 * @author Administrator
 */
public class Client {
    public static void main(String[] args) throws IOException{
        //执行四则运算
        String expStr = getExpStr();
        //赋值
        HashMap<String, Integer> var = getValue(expStr);
        Calculator cal = new Calculator(expStr);
        System.out.println("运算结果为："+expStr +"=" + cal.run(var));
    }

    /* 获得表达式 */
    public static String getExpStr() throws IOException{
        System.out.println("请输入表达式：");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    /* 获得值映射  */
    public static HashMap<String, Integer> getValue(String expStr) throws IOException{
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for(char ch : expStr.toCharArray()){
            if(ch != ‘+‘ && ch != ‘-‘){
                /* 解决反复參数的问题 */
                if(!map.containsKey(String.valueOf(ch))){
                    System.out.println("请输入 "+ch+" 的值:");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return map;
    }
}

执行结果：

请输入表达式：
a+b-c
请输入 a 的值:
100
请输入 b 的值:
2
请输入 c 的值:
101
运算结果为：a+b-c=1