Java核心篇，二十三种设计模式（十五），行为型——解析器模式

一、概述

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

语言：指的是使用规定格式和文法的一类字符组合

文法：简单点说就是我们俗称的“语法规则”

解释器模式的本质：分离实现，解释执行

二、适用场景

当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：

该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理
效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式

三、优缺点优点

扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法
容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易

缺点

执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦
会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护
可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到
对于复杂的文法比较难维护
解释器模式一般会采用递归调用方法，将会导致调试非常复杂、效率会降低

四、成员角色

AbstractExpression(抽象表达式) ===> 声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享
TerminalExpression(终结符表达式) ===> 是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对
NonterminalExpression(非终结符表达式) ===> 是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式
Context（上下文） ===> 通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值
Client（客户端） ===> 主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法

五、业务分析

假设我们输入的值是一个仅支持加减法的字符串，我们需要计算出该串的计算结果 a + b +c +d +e + f；而变量 a-f 对应的值通过一个 hashmap 给出

六、代码实现

终结符与非终结符的划分依据：

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

终结符一半是文法中的运算单元，比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式

在算术运算中，终结符表达式一般代表数字，因为数字没有办法再分，没有子类，所以是终结符

非终结符表达式(NonterminalExpression)：文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，+ 就是非终结符，解析+的解释器就是一个非终结符表达式

非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式

在算术运算中，非终结表达式一般表示运算符，因为运算符需要操作数，不能单独操作，所以各种运算符又代表加减乘除表达式，因此是非终结式的

AbstractExpression

package com.designer.interpreter.AbstractExpression;

import java.util.HashMap;


public abstract class AbstractExpression  {

    public abstract int interprete(HashMap values);
}

SymbolExpression

package com.designer.interpreter.NonterminalExpression;

import com.designer.interpreter.AbstractExpression.AbstractExpression;


public abstract class SymbolExpression extends AbstractExpression {

    protected AbstractExpression left;
    protected AbstractExpression right;

    // 非终结符表达式的解释操作只关心自己左右两个表达式的结果
    public SymbolExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }
}

AddExpression

package com.designer.interpreter.NonterminalExpression;

import com.designer.interpreter.AbstractExpression.AbstractExpression;
import java.util.HashMap;


public class AddExpression extends SymbolExpression{

    public AddExpression(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    @Override
    public int interprete(HashMap values) {
        return super.left.interprete(values) + super.right.interprete(values);
    }
}

SubExpression

package com.designer.interpreter.NonterminalExpression;

import com.designer.interpreter.AbstractExpression.AbstractExpression;
import java.util.HashMap;


public class SubExpression extends SymbolExpression {

    public SubExpression(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    // 左右两个表达式相减
    public int interprete(HashMap values) {
        return super.left.interprete(values) - super.right.interprete(values);
    }
}

VarExpression

package com.designer.interpreter.TerminalExpression;

import com.designer.interpreter.AbstractExpression.AbstractExpression;
import java.util.HashMap;


public class VarExpression extends AbstractExpression {

    private String key;

    public VarExpression(String key) {
        this.key = key;
    }

    //
    public int interprete(HashMap values) {
        return (Integer) values.get(this.key);
    }
}

Calculator

package com.designer.interpreter.Context;

import com.designer.interpreter.AbstractExpression.AbstractExpression;
import com.designer.interpreter.NonterminalExpression.AddExpression;
import com.designer.interpreter.NonterminalExpression.SubExpression;
import com.designer.interpreter.TerminalExpression.VarExpression;
import java.util.HashMap;
import java.util.Stack;


public class Calculator {

    private AbstractExpression expression;

    
    public Calculator(String expStr) {
        // 定义一个堆栈，安排运算的先后顺序
        Stack stack = new Stack<>();
        // 表达式拆分为字符数组
        char[] charArray = expStr.toCharArray();
        // 运算
        AbstractExpression left = null;
        AbstractExpression right = null;

        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+': // 加法
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new AddExpression(left, right));
                    break;

                case '-': // 减法
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;

                default: // 公式中的变量
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
            }
        }
        // 把运算结果抛出来
        this.expression = stack.pop();
    }

    // 计算结果
    public int calculate(HashMap var) {
        return this.expression.interprete(var);
    }
}

Test

package com.designer.interpreter;

import com.designer.interpreter.Context.Calculator;
import java.util.HashMap;

public class Test {

    public static void main(String[] args) {

        HashMap values = new HashMap();
        values.put("a", 10);
        values.put("b", 20);
        values.put("c", 30);
        values.put("d", 40);
        values.put("e", 50);
        values.put("f", 60);

        Calculator calc = new Calculator("a+b+c+d+e+f");
        int result = calc.calculate(values);

        System.out.println("a+b+c+d+e+f=" + result);
    }
}

Java核心篇，二十三种设计模式（十五），行为型——解析器模式

Python相关栏目本月热门文章