浅谈Java解释器模式

public abstract class Expression {

    // map中携带了表达式中的变量名(key) 和 对应的值(value)
    public abstract int interpreter(Map<String, Integer> var);

}

public class VarExpression extends Expression {

    // 表达式中对应的变量名
    String key;

    public VarExpression(String var) {
        this.key = var;
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var.get(key);
    }
}

public class SymbolExpression extends Expression {

    // +或-符号 左右两边的表达式
    Expression var1;
    Expression var2;

    public SymbolExpression(Expression var1, Expression var2) {
        this.var1 = var1;
        this.var2 = var2;
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        // 实现抽象方法
        // 该类不需要用到该方法 默认返回0
        return 0;
    }
}

public class AddExpression extends SymbolExpression {

    public AddExpression(Expression var1, Expression var2) {
        super(var1, var2);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var1.interpreter(var) + var2.interpreter(var);
    }
}

public class SubExpression extends SymbolExpression {

    public SubExpression(Expression var1, Expression var2) {
        super(var1, var2);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var1.interpreter(var) - var2.interpreter(var);
    }

}

public class Calculator {

    // 表达式
    private Expression expression;

    // 解析出表达式
    public Calculator(String expStr) {
        Stack<Expression> stack = new Stack<>();
        Expression left, right = null;
        char[] expStrCharArray = expStr.toCharArray();

        for(int i = 0; i < expStrCharArray.length; i++) {
            switch (expStrCharArray[i]) {
                case '+':// 加法运算 获取左边表达式 右边数值
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(expStrCharArray[++i]));
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':// 减法运算 获取左边表达式 右边数值
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(expStrCharArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:// 表达式中的变量
                    stack.push(new VarExpression(String.valueOf(expStrCharArray[i])));
                    break;
            }
        }
        // 最后会获得被Expression包装起来的一个表达式
        this.expression = stack.pop();
    }

    // 计算结果
    public int run(Map<String, Integer> var) {
        return this.expression.interpreter(var);
    }
}

public class Client {

    public static void main(String[] args) throws IOException {
        String expStr = getExpStr();
        Map<String, Integer> var = getValue(expStr);
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
    }

    //获得表达式
    public static String getExpStr() {
        return "a+b-c+d-e";
    }

    //获得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<>();

        for(char ch : expStr.toCharArray()) {
            if(ch != '+' && ch != '-' ) {
                if(! map.containsKey(String.valueOf(ch))) {
                    System.out.print("请输入" + String.valueOf(ch) + "的值：");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }

        return map;
    }

}