设计模式之解释器模式（Interpreter）

设计模式之解释器模式（Interpreter）

本篇为 https://github.com/iluwatar/java-design-patterns/tree/master/interpreter 阅读笔记

意图

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

优点

1、可扩展性比较好，灵活。
2、增加了新的解释表达式的方式。
3、易于实现简单文法。

缺点

1、可利用场景比较少。
2、对于复杂的文法比较难维护。
3、解释器模式会引起类膨胀。
4、解释器模式采用递归调用方法。

示例

后缀表达式解释执行

表达式抽象类

public abstract class Expression {
    public abstract int interpret();

    @Override
    public abstract String toString();
}

操作数

public class NumberExpression extends Expression {

    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    public NumberExpression(String number) {
        this.number = Integer.parseInt(number);
    }

    @Override
    public int interpret() {
        return number;
    }

    @Override
    public String toString() {
        return "number";
    }
}

加

public class PlusExpression extends Expression {

    private Expression leftExpression;
    private Expression rightExpression;

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

    @Override
    public int interpret() {
        return leftExpression.interpret() + rightExpression.interpret();
    }

    @Override
    public String toString() {
        return "+";
    }
}

减

public class MinusExpression extends Expression {

    private Expression leftExpression;
    private Expression rightExpression;

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

    @Override
    public int interpret() {
        return leftExpression.interpret() - rightExpression.interpret();
    }

    @Override
    public String toString() {
        return "-";
    }
}

乘

public class MultiplyExpression extends Expression {

    private Expression leftExpression;
    private Expression rightExpression;

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

    @Override
    public int interpret() {
        return leftExpression.interpret() * rightExpression.interpret();
    }

    @Override
    public String toString() {
        return "*";
    }
}

测试

public class APP {

    @Test
    public void interpreterTest() {
        String string = "4 3 2 - 1 + *";
        Stack<Expression> stack = new Stack<>();

        String[] strings = string.split(" ");
        for (String s : strings) {
            if (isOperator(s)) {
                Expression rightExpression = stack.pop();
                Expression leftExpression = stack.pop();
                System.out.println(MessageFormat.format("popped from stack left: {0}, right: {1}", leftExpression.interpret(), rightExpression.interpret()));
                Expression operator = getOperatorInstance(s, leftExpression, rightExpression);
                System.out.println(MessageFormat.format("operator: {0}", operator));
                int result = operator.interpret();
                NumberExpression resultExpression = new NumberExpression(result);
                stack.push(resultExpression);
                System.out.println(MessageFormat.format("push result to stack {0}", resultExpression.interpret()));
            } else {
                NumberExpression numberExpression = new NumberExpression(s);
                stack.push(numberExpression);
                System.out.println(MessageFormat.format("push to stack {0}", numberExpression.interpret()));
            }
        }
        System.out.println(MessageFormat.format("result: {0}",stack.pop().interpret()));
    }


    public boolean isOperator(String s) {
        return s.equals("+") || s.equals("-") || s.equals("*");
    }

    public static Expression getOperatorInstance(String s, Expression left, Expression right) {
        switch (s) {
            case "+":
                return new PlusExpression(left, right);
            case "-":
                return new MinusExpression(left, right);
            case "*":
                return new MultiplyExpression(left, right);
            default:
                return new MultiplyExpression(left, right);
        }
    }
}

类图