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

解釋器模式