解释器模式

Bummon2023-06-18

解释器模式

一、定义

摘自百度百科： 定义了一个解释器，来解释给定语言和文法的句子。其实质是把语言中的每个符号定义成一个（对象）类，从而把每个程序转换成一个具体的对象树。

点击查看源码

二、角色分类

抽象表达式/抽象解释器（Abstract Expression）

声明了一个所有具体表达式都要实现的抽象接口或抽象类，接口中存在一个解释操作的方法

终止符表达式（Terminal Expression）

实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符

非终止符表达式（Nonterminal Expression）

文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字

上下文（Context）

该角色的任务一般是用来存放各个表达式所对应的值和定义的法则

客户角色（Client）

具体调用方法的角色

三、实现方式

UML图

未命名文件

具体实现

接下来我们用解析数学表达式的示例来深入说明一下解释器模式

抽象解释器（Abstract Expression）

public interface AbstractExpression {

    /**
     * 解释操作
     *
     * @return
     */
    int interpret();
}

终止符表达式（Terminal Expression）

public abstract class TerminalExpression implements AbstractExpression {
    protected AbstractExpression expressionA;
    protected AbstractExpression expressionB;

    public TerminalExpression(AbstractExpression expressionA, AbstractExpression expressionB) {
        this.expressionA = expressionA;
        this.expressionB = expressionB;
    }
}

非终止符表达式（Nonterminal Expression）

/**
 * 相加
 */
public class AddNonterminalExpression extends TerminalExpression {
    public AddNonterminalExpression(AbstractExpression expressionA, AbstractExpression expressionB) {
        super(expressionA, expressionB);
    }

    public int interpret() {
        return this.expressionA.interpret() + this.expressionB.interpret();
    }
}

/**
 * 相减
 */
public class SubNonterminalExpression extends TerminalExpression {
    public SubNonterminalExpression(AbstractExpression expressionA, AbstractExpression expressionB) {
        super(expressionA, expressionB);
    }

    public int interpret() {
        return this.expressionA.interpret() - this.expressionB.interpret();
    }
}

public class NumNonterminalExpression implements AbstractExpression {
    private int value;

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

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

上下文对象（Context）

public class Context {
    private Stack<AbstractExpression> stack = new Stack<AbstractExpression>();

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

    /**
     * 解析表达式
     */
    private void parse(String expression) {
        String[] elements = expression.split(" ");
        AbstractExpression expressionA, expressionB;

        for (int i = 0; i <elements.length; i++) {
            String operator = elements[i];
            if (Context.isOperator(operator)) {
                expressionA = this.stack.pop();
                System.out.println("出栈: " + expressionA.interpret());
                expressionB = new NumNonterminalExpression(Integer.valueOf(elements[++i]));
                TerminalExpression res = Context.util(expressionA, expressionB, operator);
                this.stack.push(res);
                System.out.println("计算: " + expressionA.interpret() + operator + expressionB.interpret());
                System.out.println("计算结果: " + res.interpret() + " 入栈");
            } else {
                NumNonterminalExpression numNonterminalExpression = new NumNonterminalExpression(Integer.valueOf(elements[i]));
                this.stack.push(numNonterminalExpression);
                System.out.println("入栈: " + numNonterminalExpression.interpret());
            }
        }
    }

    /**
     * 计算结果
     */
    public int caculate() {
        int interpret = this.stack.pop().interpret();
        System.out.println("计算结果为：" + interpret + " 出栈");
        return interpret;
    }

    /**
     * 计算结果
     */
    public static TerminalExpression util(AbstractExpression a, AbstractExpression b, String symbol) {
        if (symbol.equals("+")) {
            return new AddNonterminalExpression(a, b);
        } else if (symbol.equals("-")) {
            return new SubNonterminalExpression(a, b);
        } else {
            return null;
        }
    }

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

客户角色（Client）

public class Client {

    public static void main(String[] args) {
        // 创建上下文对象进行解释
        Context calculatorContext = new Context("1 + 4");
        // 获取执行结果
        System.out.println("calculatorContext.calculate() = " + calculatorContext.caculate());

        Context calculatorContext2 = new Context("1 + 4 - 5");
        System.out.println("calculatorContext.calculate() = " + calculatorContext2.caculate());
    }
}

运行结果

入栈: 1
出栈: 1
计算: 1+4
计算结果: 5 入栈
计算结果: 5 出栈
calculatorContext.calculate() = 5
入栈: 1
出栈: 1
计算: 1+4
计算结果: 5 入栈
出栈: 5
计算: 5-5
计算结果: 0 入栈
计算结果: 0 出栈
calculatorContext.calculate() = 0