设计模式(行为型设计模式——解释器模式)

设计模式(行为型设计模式------解释器模式)

解释器模式

基本定义

给分析对象定义一个语言,并定义该语言的文法表示,设计一个解析器来解释语言中的句子。

模式结构

  • AbstractExpression:抽象表达式。声明一个抽象的解释操作,该接口为抽象语法树中所有的节点共享。

  • TerminalExpression:终结符表达式。现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。解释结果。

  • NonterminalExpression:非终结符表达式。为文法中的非终结符相关的解释操作。一般情况下以子类的形式出现。

  • Context:环境类。包含解释器之外的一些全局信息。

  • Client: 客户端类

代码实现

AbstractExpression:抽象解释器
java 复制代码
public interface Node {
    int interpreter();
}
TerminalExpression:终结符表达式
java 复制代码
/**
* 返回最终值
*/
public class ValueNode implements Node {


    private int value;


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


    @Override
    public int interpreter() {
        return this.value;
    }
}
NonterminalExpression:非终结符表达式
java 复制代码
public class SymbolNode implements Node{

    Node left;
    Node right;

    public SymbolNode(Node left, Node right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter() {
        return 0;
    }
}
java 复制代码
/**
* 加法
*/
public class AddNode extends SymbolNode {

    public AddNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() + right.interpreter();
    }
}
java 复制代码
/**
* 减法
*/
public class SubtractNode extends SymbolNode {

    public SubtractNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() - right.interpreter();
    }
}
java 复制代码
/**
* 乘法
*/
public class MulNode extends SymbolNode {

    public MulNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() * right.interpreter();
    }
}
java 复制代码
/**
* 除法
*/
public class DivisionNode extends SymbolNode {

    public DivisionNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() / left.interpreter();
    }
}
Context:环境类
java 复制代码
public class Calculator {


    private Node node;


    private String statement;


    public void build(String statement){
        Node left = null;
        Node right = null;
        //提供容器,存储关系
        Stack stack = new Stack();
        //重点,将node存入stack, 存储前需确认表达式的顺序和执行结果
        //以空格分隔
        String[] statementArr = statement.split(" ");
        int index = 0;
        int value;
        for (String state : statementArr){
            index++;
            switch (state){
                case "*" ://乘法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new MulNode(left, right));
                    break;


                case "/" : //除法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new DivisionNode(left, right));
                    break;
                    
                case "+" : //加法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new AddNode(left, right));
                    break;


                case "-" : //减法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new SubtractNode(left, right));
                    break;


                default:
                    stack.push(new ValueNode(Integer.parseInt(state)));
                    break;
            }


        }
        //stack pop显示栈顶元素并且移除栈顶元素
        this.node = (Node) stack.pop();
    }


    public int compute(){
        return node.interpreter();
    }


}
Client: 客户端类
java 复制代码
@Slf4j
public class Test {
    public static void main(String[] args){
    //约定以空格分割
        String statement = "3 * 2 / 2 + 1 - 2";
        Calculator calculator = new Calculator();
        calculator.build(statement);
        int result = calculator.compute();
        log.info("statement : {} ------> value = {}", statement, result);
    }
}

优点

  • 扩展性好。由于在解释器模式中使用类来表示语言的文法规则,因此可以通过继承等机制来改变或扩展文法。

  • 容易实现。在语法树中的每个表达式节点类都是相似的,所以实现其文法较为容易

缺点

  • 执行效率比较低,可利用场景比较少。

  • 解释器模式中的每条规则至少需要定义一个类,当包含的文法规则很多时,类的个数将急剧增加,导致系统难以管理与维护。

  • 可应用的场景比较少。在软件开发中,需要定义语言文法的应用实例非常少,所以这种模式很少被使用到。

使用场景

  • 当一个语言需要解释执行,并且语言中的句子可以表示为一个抽象语法树的时候,如 XML 文档解释。

  • 当问题重复出现,且可以用一种简单的语言来进行表达时。

  • 当语言的文法较为简单,且执行效率不是关键问题时。

模式总结

  • 由于在解释器模式中使用类来表示语言的文法规则,因此可以通过继承等机制来改变或扩展文法。

  • 虽然解释器的可扩展性强,但是如果语法规则的数目太大的时候,该模式可能就会变得异常复杂。所以解释器模式适用于文法较为简单的。

相关推荐
一只叫煤球的猫1 小时前
【🤣离谱整活】我写了一篇程序员掉进 Java 异世界的短篇小说
java·后端·程序员
斐波娜娜1 小时前
Maven详解
java·开发语言·maven
Bug退退退1231 小时前
RabbitMQ 高级特性之事务
java·分布式·spring·rabbitmq
程序员秘密基地2 小时前
基于html,css,vue,vscode,idea,,java,springboot,mysql数据库,在线旅游,景点管理系统
java·spring boot·mysql·spring·web3
皮皮林5512 小时前
自从用了CheckStyle插件,代码写的越来越规范了....
java
小码氓2 小时前
Java填充Word模板
java·开发语言·spring·word
会飞的天明2 小时前
Java 导出word 实现饼状图导出--可编辑数据
java·word
Muxiyale2 小时前
使用spring发送邮件,部署ECS服务器
java·服务器·spring
01传说3 小时前
vue3 配置安装 pnpm 报错 已解决
java·前端·vue.js·前端框架·npm·node.js
hunzi_13 小时前
搭建商城系统
java·uni-app·php