设计模式——解释器模式（Interpreter Pattern）

解释器模式（Interpreter Pattern）给定一个语言，定义规则的一种表示，定义一个解释器，来解释语言中的句子。为了解释一种语言，为此语言而创建的解释器，可以看作是语法分析工具。属于行为型模式。

用解释器模式简单实现数学加减运算

解释器接口

public interface IMathInterpreter {
    int interpret();
}

终结表达式

public class TerminalInterpreter implements IMathInterpreter {
    private int value;

    public TerminalInterpreter(int value) {
        this.value = value;
    }

    @Override
    public int interpret() {
        return this.value;
    }
}

非终结表达式

public abstract class NonTerminalInterpreter implements IMathInterpreter {
    // 用来表示运算符左右的数字
    protected IMathInterpreter left;
    protected IMathInterpreter right;

    public NonTerminalInterpreter(IMathInterpreter left, IMathInterpreter right) {
        this.left = left;
        this.right = right;
    }
}

加法运算解释器

public class AddInterpreter extends NonTerminalInterpreter {
    public AddInterpreter(IMathInterpreter left, IMathInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() + this.right.interpret();
    }
}

减法运算解释器

public class SubInterpreter extends NonTerminalInterpreter {
    public SubInterpreter(IMathInterpreter left, IMathInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() - this.right.interpret();
    }
}

最终运算类，通过调用不同解释器来得到最终结果

public class Calculator {
    private Stack stack = new Stack<>();
    public Calculator(String expression) {
        parse(expression);
    }

    private void parse(String expression) {
        String[] elements = expression.split(" ");
        IMathInterpreter left, right, result;
        for (int i = 0; i < elements.length; i++) {
            String element = elements[i];
            if ("+".equals(element) || "-".equals(element)) {
                left = this.stack.pop();
                right = new TerminalInterpreter(Integer.parseInt(elements[++i]));
                System.out.println("出栈：" + left.interpret() + "和" + right.interpret() + ", 运算符号：" + element);
                if ("+".equals(element)) {
                    this.stack.push(new AddInterpreter(left, right));
                    System.out.println("入栈：" + new AddInterpreter(left, right).interpret() + ", 运算符号：" + element);
                } else if ("-".equals(element)) {
                    this.stack.push(new SubInterpreter(left, right));
                    System.out.println("入栈：" + new SubInterpreter(left, right).interpret());
                }
            } else {
                TerminalInterpreter terminalInterpreter = new TerminalInterpreter(Integer.parseInt(element));
                this.stack.push(terminalInterpreter);
                System.out.println("入栈：" + terminalInterpreter.interpret());
            }
        }
    }

    public int calculate() {
        return this.stack.pop().interpret();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("10 + 20 + 30 + 40 + 50 - 50");
        System.out.println("运算结果："+calculator.calculate());
    }
}

执行结果

入栈：10
出栈：10和20, 运算符号：+
入栈：30, 运算符号：+
出栈：30和30, 运算符号：+
入栈：60, 运算符号：+
出栈：60和40, 运算符号：+
入栈：100, 运算符号：+
出栈：100和50, 运算符号：+
入栈：150, 运算符号：+
出栈：150和50, 运算符号：-
入栈：100
运算结果：100

框架中解释器

JDK中正则的解释器Pattern，Spring中表达式的解释器ExpressionParser