当前位置：首页 > news >正文

23种设计模式-解释器(Interpreter)设计模式

news 来源：原创 2025/6/10 5:01:23

解释器设计模式

🚩什么是解释器设计模式？
🚩解释器设计模式的特点
🚩解释器设计模式的结构
🚩解释器设计模式的优缺点
🚩解释器设计模式的Java实现
🚩代码总结
🚩总结

🚩什么是解释器设计模式？

解释器设计模式（Interpreter Pattern） 是一种 行为型设计模式，它定义了一个语言的文法，并建立一个解释器来解释该语言中的句子。这种模式通常用于SQL解析、符号处理引擎等场景中。

使用场景

当需要 解释执行某种语言或表达式 时
当语言文法 较为简单 且 效率不是关键问题 时
当需要 频繁地解释执行类似语法 时
适用于 正则表达式、SQL解析、数学公式计算 等场景

🚩解释器设计模式的特点

定义语言的文法：为语言创建语法规则
构建解释器：为语法规则构建解释器
扩展性好：可以方便地扩展和修改语法规则
易于实现简单文法：对于简单文法实现起来非常直接
解释执行：能够解释执行定义好的语言

🚩解释器设计模式的结构

解释器模式主要包含以下部分：

AbstractExpression（抽象表达式）：声明一个抽象的解释操作
TerminalExpression（终结符表达式）：实现与文法中的终结符相关的解释操作
NonterminalExpression（非终结符表达式）：实现文法中非终结符的解释操作
Context（上下文）：包含解释器之外的一些全局信息
Client（客户端）：构建表示该文法定义的语言中一个特定句子的抽象语法树

🚩解释器设计模式的优缺点

✅ 优点

易于改变和扩展文法：因为使用类来表示文法规则
易于实现简单文法：实现文法变得更容易
增加新的解释表达式方便：符合开闭原则
将语法分析与执行分离：语法分析由不同类完成

❌ 缺点

复杂文法难以维护：对于复杂文法，类层次结构会变得庞大而难以管理
执行效率较低：解释器模式通常使用递归调用，效率不高
应用场景有限：只在特定领域（如编译器、规则引擎等）有用

🚩解释器设计模式的Java实现

代码地址：GitHub

创建 Expression（抽象表达式） 接口

/**
 * @author hanson.huang
 * @version V1.0
 * @InterfaceName Expression
 * @Description 抽象表达式
 * @date 2025/3/25 17:38
 **/
public interface Expression {
    public boolean Interpret(String info);
}

创建 TerminalExpression（终结符表达式）

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName TerminalExpression
 * @Description 终结符表达式
 * @date 2025/3/25 17:38
 **/
public class TerminalExpression implements Expression {

    private Set<String> set = new HashSet<>();

    public TerminalExpression(String[] data) {
        // for (遍历对象类型 对象名 : 遍历对象)
        for (String str : data) {
            set.add(str);
        }
    }

    @Override
    public boolean Interpret(String info) {
        return set.contains(info);
    }
}

创建 NonterminalExpression（非终结符表达式）

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName NonterminalExpression
 * @Description 创建 NonterminalExpression（非终结符表达式）
 * @date 2025/3/25 17:42
 **/
public class NonterminalExpression implements Expression{

    private Expression region;
    private Expression person;

    public NonterminalExpression(Expression region, Expression person) {
        this.region = region;
        this.person = person;
    }

    @Override
    public boolean Interpret(String info) {
        String[] str = info.split("的");

        // B区的调试人员 --> str = {"B区", "调试人员"}
        return region.Interpret(str[0]) && person.Interpret(str[1]);
    }
}

创建 Context（上下文） 类

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName Context
 * @Description 上下文
 * @date 2025/3/25 17:44
 **/
public class Context {
    private String[] regions = {"A区", "B区", "C区"};
    private String[] persons = {"开发人员", "测试人员", "调试人员"};

    private NonterminalExpression nonterminal;

    public Context() {
        TerminalExpression region = new TerminalExpression(regions);
        TerminalExpression person = new TerminalExpression(persons);
        nonterminal = new NonterminalExpression(region, person);
    }

    public void check(String info) {
        boolean bool = nonterminal.Interpret(info);
        if (bool) {
            System.out.println("识别成功");
        } else {
            System.out.println("识别失败");
        }
    }
}

测试解释器模式

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName InterpreterPattern
 * @Description 测试解释器模式
 * @date 2025/3/25 17:47
 **/
public class InterpreterPattern {


    public static void main(String[] args) {
        Context context = new Context();

        context.check("A区的开发人员");
        context.check("B区的调试人员");
        context.check("C区的测试人员");

        System.out.println("==========");

        context.check("D区的程序员");
        context.check("D区的测试员");
        context.check("A区的程序员");
    }
}