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

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

解释器模式

基本定义

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

模式结构

  • 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 文档解释。

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

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

模式总结

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

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

相关推荐
重庆小透明20 分钟前
力扣刷题记录【1】146.LRU缓存
java·后端·学习·算法·leetcode·缓存
lang2015092825 分钟前
Reactor操作符的共享与复用
java
TTc_36 分钟前
@Transactional事务注解的批量回滚机制
java·事务
wei_shuo1 小时前
飞算 JavaAI 开发助手:深度学习驱动下的 Java 全链路智能开发新范式
java·开发语言·飞算javaai
欧阳秦穆2 小时前
apoc-5.24.0-extended.jar 和 apoc-4.4.0.36-all.jar 啥区别
java·jar
岁忧2 小时前
(LeetCode 面试经典 150 题 ) 58. 最后一个单词的长度 (字符串)
java·c++·算法·leetcode·面试·go
Java初学者小白2 小时前
秋招Day14 - Redis - 应用
java·数据库·redis·缓存
代码老y2 小时前
Spring Boot + 本地部署大模型实现:优化与性能提升
java·spring boot·后端
码农秋2 小时前
设计模式系列(10):结构型模式 - 桥接模式(Bridge)
设计模式·桥接模式
GodKeyNet2 小时前
设计模式-桥接模式
java·设计模式·桥接模式