设计模式系统回顾（19）解释器模式

按照规定的语法（文法）来进行解析的一种设计模式
终结符表达式和非终结符表达式

• 终结符表达式（Terminal Expression）：实现文法中与终结符有关的解释操作。文法中每一个终结符都有一个具体的终结符表达式与之相对应。比如我们的 R=M+N 运算，M 和 N 就是终结符，对应的解析 M 和 N 的解释器就是终结符表达式
• 非终符结表达式（Nonterminal Expression）：实现文法中与非终结符有关的解释操作。文法中的每一条规则都对应了一个非终结符表达式。非终结表达式一般是文法中的运算符或者关键字，如上面公示：R=M+N 中的“+”号就是非终结符，解析“+”号的解释器就是一个非终结符表达式

public interface IExpression {
    int interpret();//用来解释表达式的方法
}

/**
 * 非终结表达式-抽象表达式
 */
public abstract class AbstractNonTerminalExpression implements IExpression{
    protected IExpression leftExpression;//非终结表达式左边表达式，一般为数字
    protected IExpression rightExpression;//非终结表达式右边表达式，一般为数字

    public AbstractNonTerminalExpression(IExpression leftExpression, IExpression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
}

/**
 * 非终结表达式-具体表达式-减法表达式
 */
public class SubExpression extends AbstractNonTerminalExpression {

    public SubExpression(IExpression leftExpression, IExpression rightExpression) {
        super(leftExpression, rightExpression);
    }

    @Override
    public int interpret() {//解释器，将左右两个终结符的值相减
        return this.leftExpression.interpret() - this.rightExpression.interpret();
    }
}

public class NumberExpression implements IExpression{
    private int value;//终结表达式的值

    public NumberExpression(String value) {
        this.value = Integer.valueOf(value);
    }

    @Override
    public int interpret() {//解释非终结表达式
        return this.value;//直接返回值就行了
    }
}


public class ExpressionContext {
    private Stack<IExpression> stack = new Stack<>();//定义一个栈，计算一般都用栈，利用其后入先出的特性

    public ExpressionContext(String expression) {
        this.parse(expression);
    }

    private void parse(String expression) {
        String[] elementArr = expression.split(" ");//为了简单，直接以空格来切割，所以测试的时候每个数字和符号之间都要有空格
        for (int i=0;i<elementArr.length;i++){
            String element = elementArr[i];
            if (element.equals("+")){//加法
                IExpression leftExpression = stack.pop();//栈内元素出栈
                IExpression rightExpression = new NumberExpression(elementArr[++i]);//取出+号后的下一个元素
                IExpression addExpression = new AddExpression(leftExpression,rightExpression);
                stack.push(new NumberExpression(addExpression.interpret() + ""));//将计算结果入栈
            }else if (element.equals("-")){//减法
                IExpression leftExpression = stack.pop();//栈内元素出栈
                IExpression rightExpression = new NumberExpression(elementArr[++i]);//取出-号后的下一个元素
                IExpression subExpression = new SubExpression(leftExpression,rightExpression);
                stack.push(new NumberExpression(subExpression.interpret() + ""));//将计算结果入栈
            }else{
                stack.push(new NumberExpression(element));//如果是数字则直接入栈
            }
        }
    }

    public int calcuate(){//运算结果
        return stack.pop().interpret();//经过前面解析，到这里stack内只会剩下唯一一个数字，即运算结果
    }
}


public class TestInterpreter {
    public static void main(String[] args) {
        ExpressionContext context = new ExpressionContext("666 + 888 - 777");//注意每个符号间要包含空格
        System.out.println(context.calcuate());//输出计算结果
        context = new ExpressionContext("123 - 456 + 11");
        System.out.println(context.calcuate());//输出计算结果
    }
}

使用场景
1.有需要重复解析的问题
2.需要解释一些语法
优点
扩展性比较强
缺点
1.规则复杂时会引起类膨胀
2.影响效率