四则运算的问题

通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求

先输入表达式的形式，比如：a+b-c,要求表达式的字母不能重复。
再分别输入a、b、c的值，要求表达式的字母不能重复。最后求出结果。

解释器模式

原理类图：

类图说明：

Context：是环境角色，含有解释器之外的全部信息。
Expression:抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有节点所共享。
TeminalExpression:为终结表达式，实现与文法中终结符相关的解释操作（如:例子中的a、b、c等）。
NoTeminalExpression:为非终结表达式，为文法中非终结符相关的解释操作（如：例子中的+、-）。

用解释器模式实现四则运算问题，只简单实现+，-

类图：代码：

public interface Expression {
    int interpret(Map<String, Integer> var2ValueMap);
}

public class VarExpression implements Expression {
    private String var;

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

    @Override
    public int interpret(Map<String, Integer> var2ValueMap) {
        return var2ValueMap.get(this.var);
    }
}

public class SymbolExpression implements Expression {
    protected Expression left;
    protected Expression right;

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

    @Override
    public int interpret(Map<String, Integer> var2ValueMap) {
        return 0;
    }
}

class AddExpression extends SymbolExpression {
    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpret(Map<String, Integer> var2ValueMap) {
        return this.left.interpret(var2ValueMap) + this.right.interpret(var2ValueMap);
    }
}

class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpret(Map<String, Integer> var2ValueMap) {
        return this.left.interpret(var2ValueMap) - this.right.interpret(var2ValueMap);
    }
}

public class Calculator {
    public static int calc(String express, Map<String, Integer> var2ValueMap) {
        Stack<Expression> stack = new Stack();
        char[] chars = express.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == '+') {
                Expression leftExpression = stack.pop();
                Expression rightExpression = new VarExpression(chars[i + 1] + "");
                stack.push(new AddExpression(leftExpression, rightExpression));
                i++;
            } else if (chars[i] == '-') {
                Expression leftExpression = stack.pop();
                Expression rightExpression = new VarExpression(chars[i + 1] + "");
                stack.push(new SubExpression(leftExpression, rightExpression));
                i++;
            } else {
                stack.push(new VarExpression(chars[i] + ""));
            }
        }

        return stack.pop().interpret(var2ValueMap);
    }

    public static void main(String[] args) {
        String express = "a+b-c";
        Map<String, Integer> var2ValueMap = new HashMap<>();
        var2ValueMap.put("a", 10);
        var2ValueMap.put("b", 20);
        var2ValueMap.put("c", 10);
        System.out.println(calc(express, var2ValueMap));
    }
}

解释器模式的注意实现即细节

当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性。
应用场景：编译器，表达式计算，正则表达式，机器人等。
使用解释器可能带来的问题，解释器模式会引起类的膨胀，解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低。

解释器模式--java实现

四则运算的问题

解释器模式

解释器模式的注意实现即细节