21-解释器模式

21-解释器模式

1.解释器模式

1. 不使用解释器模式实现简单的加减乘除。

public class ExpressionInterpreter {

    private final Deque<Long> numbers = new LinkedList<>();

    public long interpret(String expression) {
        String[] element = expression.split(" ");
        int length = element.length;
        for (int i = 0;i < (length + 1) / 2;i++) {
            numbers.add(Long.parseLong(element[i]));
        }

        for (int i = (length + 1) / 2;i < length;i++) {
            String operator = element[i];
            boolean isValid = "+".equals(operator) || "-".equals(operator)
                    || "*".equals(operator) || "/".equals(operator);
            if (!isValid) {
                throw new RuntimeException("Expression is invalid: " + expression);
            }

            long n1 = numbers.pollFirst();
            long n2 = numbers.pollFirst();
            long result = 0;
            if ("+".equals(operator)) {
                result = n1 + n2;
            } else if ("-".equals(operator)) {
                result = n1 - n2;
            } else if ("*".equals(operator)) {
                result = n1 * n2;
            } else if ("/".equals(operator)) {
                result = n1 / n2;
            }
            numbers.addFirst(result);
        }
        if (numbers.size() != 1) {
            throw new RuntimeException("Expression is invalid: " + expression);
        }
        return numbers.pop();
    }

    public static void main(String[] args) {
        /*
        1 8-3=5 -> 5 2 4 + *
        2 5+2=7 -> 7 4 *
        3 7*4=28
         */
        String expression = "8 3 2 4 - + *";
        ExpressionInterpreter expressionInterpreter = new ExpressionInterpreter();
        long number = expressionInterpreter.interpret(expression);
        System.out.println(number);
    }
}

2. 使用解释器模式实现加减乘除，将具体的解析工作拆分到NumberExpression、AdditionExpression中。

public interface Expression {

    long interpret();
}

public class NumberExpression implements Expression {

    private final long number;
    public NumberExpression(long number) {
        this.number = number;
    }
    public NumberExpression(String number) {
        this.number = Long.parseLong(number);
    }

    @Override
    public long interpret() {
        return this.number;
    }
}
public class AdditionExpression implements Expression {

    private final Expression expression1;
    private final Expression expression2;
    public AdditionExpression(Expression e1, Expression e2) {
        this.expression1 = e1;
        this.expression2 = e2;
    }

    @Override
    public long interpret() {
        return this.expression1.interpret() + this.expression2.interpret();
    }
}
// SubtractionExpression、MultiplicationExpression、
// DivisionExpression代码和AdditionExpression相似，省略。

public class ExpressionInterpreter {

    private final Deque<Expression> numbers = new LinkedList<>();

    public long interpret(String expression) {
        String[] element = expression.split(" ");
        int length = element.length;
        for (int i = 0;i < (length + 1) / 2;i++) {
            numbers.add(new NumberExpression(element[i]));
        }

        for (int i = (length + 1) / 2;i < length;i++) {
            String operator = element[i];
            boolean isValid = "+".equals(operator) || "-".equals(operator)
                    || "*".equals(operator) || "/".equals(operator);
            if (!isValid) {
                throw new RuntimeException("Expression is invalid: " + expression);
            }

            Expression e1 = numbers.pollFirst();
            Expression e2 = numbers.pollFirst();
            Expression result = null;
            if ("+".equals(operator)) {
                result = new AdditionExpression(e1, e2);
            } else if ("-".equals(operator)) {
                result = new SubtractionExpression(e1, e2);
            } else if ("*".equals(operator)) {
                result = new MultiplicationExpression(e1, e2);
            } else if ("/".equals(operator)) {
                result = new DivisionExpression(e1, e2);
            }
            numbers.addFirst(new NumberExpression(result.interpret()));
        }
        if (numbers.size() != 1) {
            throw new RuntimeException("Expression is invalid: " + expression);
        }
        return numbers.pop().interpret();
    }

    public static void main(String[] args) {
        /*
        1 8-3=5 -> 5 2 4 + *
        2 5+2=7 -> 7 4 *
        3 7*4=28
         */
        String expression = "8 3 2 4 - + *";
        ExpressionInterpreter expressionInterpreter = new ExpressionInterpreter();
        long number = expressionInterpreter.interpret(expression);
        System.out.println(number);
    }
}

2.解释器模式总结

1. <<设计模式：可复用面向对象软件的基础>>中解释器模式的定义：解释器模式为某个语言定义语法（或文本），并定义解释器处理这个语法。
2. 解释器模式用来描述如何构建一个简单的语言解释器，相比命令模式，解释器模式更加的小众，只有在一些特定领域才会被使用到，如编译器、规则引擎、正则表达式。