设计模式——解释器模式

解释器模式是什么?

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子

解释器模式解决什么问题？

如匹配字符串的正则表达式，解释器为其定义了一个文法用于表示和解释正则表达式

当有一个语言需要解释执行，并且可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式

解释器模式实现

创建接口Expression

public interface Expression {
    int interpreter(Map<String, Integer> map);
}

创建变量解释器，返回

class VarExpression implements Expression {
    private String Key;

    public VarExpression(String key) {
        Key = key;
    }

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

创建符号解释器

class SymbolExpression implements Expression {
    protected Expression leftExpression;
    protected Expression rightExpression;

    public SymbolExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

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

class SubExpression extends SymbolExpression {
    public SubExpression(Expression leftExpression, Expression rightExpression) {
        super(leftExpression, rightExpression);
    }

    @Override
    public int interpreter(Map<String, Integer> map) {
        return leftExpression.interpreter(map) - rightExpression.interpreter(map);
    }
}

class AddExpression extends SymbolExpression {
    public AddExpression(Expression leftExpression, Expression rightExpression) {
        super(leftExpression, rightExpression);
    }

    @Override
    public int interpreter(Map<String, Integer> map) {
        return leftExpression.interpreter(map) + rightExpression.interpreter(map);
    }
}

使用时，遇到变量压入栈，遇到符号弹出并计算结果再压入栈

class Calculator {
    private Expression mExpression;
    public Calculator(String strExpression) {
        char[] charArray = strExpression.toCharArray();
        Stack<Expression> stack = new Stack<>();
        Expression left;
        Expression right;
        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])));
                    break;
            }
        }
        this.mExpression = stack.pop();
    }
    public int calculate(Map<String, Integer> map) {
        return mExpression.interpreter(map);
    }
}

如下，将“a+b-c+d”解释为1+5-2+3

String strExpression = "a+b-c+d";
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 5);
map.put("c", 2);
map.put("d", 3);

Calculator calculator = new Calculator(strExpression);
System.out.println("表达式: " + strExpression + " 结果=" + calculator.calculate(map));