解释器模式：定义语言语法与解释器

FreeGuideOnline 最新 2026-06-18

什么是解释器模式

解释器模式（Interpreter Pattern）是一种行为型设计模式，它用于定义一种语言的文法表示，并提供一个解释器来处理该语言中的句子。换句话说，当你需要为一个简单的“语言”设计一个语法解析器时，解释器模式提供了一种将每个语法规则封装成一个类的方案，客户端可以轻松地组合这些规则来解析和执行特定语句。

该模式的核心思想是：将一句话（表达式）解释为该语言定义的一个抽象语法树，然后递归地遍历这棵树求值。

模式结构

解释器模式通常包含以下四个角色：

抽象表达式（Abstract Expression）：声明一个抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
终结符表达式（Terminal Expression）：实现了与文法中的终结符相关联的解释操作。终结符是语言中最基本的元素，不再包含其他表达式。
非终结符表达式（Non-terminal Expression）：为文法中的非终结符实现解释操作。非终结符通常包含一个或多个对其他表达式（可以是终结符或非终结符）的引用，解释时一般会递归调用其子表达式的解释方法。
上下文（Context）：包含解释器之外的一些全局信息，通常是需要被解释的语句的字符串表示，以及在解释过程中需要的变量值或环境信息。
客户端（Client）：负责构建（或者接收）抽象语法树，并调用解释操作。

适用场景

解释器模式建议在以下情况使用：

有一个简单的语言需要解释执行，而且文法相对简单，不会过于复杂。
需要重复发生的问题可以使用一种简单的语言进行表达，例如：表达式求值、规则引擎、简单命令解析。
效率不是最关键的因素——如果性能要求极高，解释器模式可能会因递归调用和类数量膨胀而成为瓶颈，此时可以考虑其他解析手段（如专门的编译器工具）。
语言的文法规则比较稳定，不会频繁变化。因为修改文法意味着要修改大量的类。

实现步骤

定义语言的文法：明确终结符和非终结符规则，确定语法结构（通常用BNF或类似形式表达）。
创建抽象表达式类：声明一个公共的 interpret(context) 方法。
创建终结符表达式类：实现 interpret()，直接处理上下文中的对应符号（如数字、变量）。
创建非终结符表达式类：每个非终结符规则对应一个类，通常组合若干抽象表达式对象，在其 interpret() 方法中递归调用子对象的解释，并组合结果。
提供上下文：保存输入语句和运行时数据，供表达式对象使用。
在客户端构建语法树：根据具体输入解析成对应的表达式对象树，然后触发解释。

代码示例：简单数学表达式解释器

假设我们需要解释仅包含整数、加法和减法的表达式，例如 "3 + 5 - 2"。

第一步：定义文法

表达式    ::= 数字 | 表达式 '+' 数字 | 表达式 '-' 数字
数字      ::= 0-9 的组合

在这个文法中，数字是终结符，加法和减法组合为非终结符。

第二步：实现抽象表达式

public interface Expression {
    int interpret(Context context);
}

第三步：上下文

public class Context {
    private String input;
    private int index; // 当前解析位置

    public Context(String input) {
        this.input = input.replaceAll(" ", "");
        this.index = 0;
    }

    public String nextToken() {
        // 获取下一个数字令牌（假设格式正确）
        int start = index;
        while (index < input.length() && Character.isDigit(input.charAt(index))) {
            index++;
        }
        return input.substring(start, index);
    }

    public boolean hasMoreTokens() {
        // 跳过后续运算符的空格等，这里简单判断是否还有字符
        return index < input.length();
    }
}

第四步：终结符表达式 – 数字

public class NumberExpression implements Expression {
    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    @Override
    public int interpret(Context context) {
        return number;
    }
}

第五步：非终结符表达式 – 加法

public class AddExpression implements Expression {
    private Expression left;
    private Expression right;

    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

减法表达式 SubtractExpression 类似，将加法改成减法。

第六步：客户端构建语法树

public class Client {
    public static Expression parse(Context context) {
        // 先解析第一个数字
        String token = context.nextToken();
        Expression result = new NumberExpression(Integer.parseInt(token));

        // 循环处理后续的运算符和数字
        while (context.hasMoreTokens()) {
            char operator = context.nextToken().charAt(0); // 为简化，这里假设下个令牌是运算符
            token = context.nextToken();
            Expression right = new NumberExpression(Integer.parseInt(token));

            if (operator == '+') {
                result = new AddExpression(result, right);
            } else if (operator == '-') {
                result = new SubtractExpression(result, right);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Context context = new Context("3 + 5 - 2");
        Expression expression = parse(context);
        System.out.println(expression.interpret(context)); // 输出 6
    }
}

这个例子展示了如何为一个小型语言建立解释器。实际应用中，你可以扩展支持乘除、括号、变量赋值等，但这会使类数量急剧增加。

优点与缺点

优点

扩展性好：增加新的解释规则只需新增一个表达式类，符合开闭原则。
易于实现文法：将每个文法规则映射为一个类，结构清晰，便于实现和修改简单语言。
表达能力：可以方便地表示以抽象语法树形式存在的复合表达式。

缺点

类数量膨胀：每个规则至少要一个类，复杂文法则类数巨大，难以维护。
递归调用影响效率：解释器本质上是递归遍历树结构，性能通常不如直接编译执行。
调试困难：复杂的嵌套表达式不易追踪错误。
不适合复杂文法：如果语言文法非常复杂（例如完整的编程语言），解释器模式会使系统过于臃肿，应使用专业的解析器生成工具（如 ANTLR、JavaCC）。

实际应用案例

解释器模式在常见软件和库中被以更强大的形式引入：

正则表达式：Java 中的 java.util.regex.Pattern 本质上是一个复杂的解释器，它编译正则文法为内部结构并解释匹配。
SQL 解析：很多轻量级数据库工具会实现一个 SQL 子集的解释器来解析查询并翻译为底层操作。
规则引擎：业务规则引擎（如 Drools）允许用自定义语言定义规则，解释器负责解析规则语句并执行。
数学表达式计算器：如 Apache Commons JEXL、Spring Expression Language (SpEL) 均实现了类似解释器模式的表达式求值。

总结

解释器模式提供了一种优雅的方式，通过定义类来映射语言的文法规则，使你可以轻松构建一个小型的解释器。该模式的核心是将终结符和非终结符分别封装，利用递归组合构建抽象语法树。虽然它具有清晰的结构和良好的扩展性，但只适用于文法简单、稳定且性能要求不高的场景。当语言变得复杂时，建议借助专业的语法分析工具，而将解释器模式作为学习设计模式或实现简单 DSL 的一种手段。