解释器模式

概念

解释器模式是一种行为型设计模式，用于定义一种语言的语法规则，并提供解释器来解释该语言中的表达式。其核心作用是将复杂的语法分解为简单的语法单元，通过递归组合的方式构建抽象语法树（AST），最终由解释器逐层解释执行。

作用

1.将复杂的语法分解为简单的语法单元，通过递归组合构建抽象语法树（AST），实现表达式的结构化解析。

2.将语法解析逻辑与具体业务操作分离，符合单一职责原则，提升代码可维护性。

3.支持灵活扩展语法规则，新增表达式类型时只需添加对应的解释器类，无需修改现有代码。

场景

1.需要解释特定领域的语言，如数学公式、正则表达式、SQL查询、配置文件解析等。

2.语法相对简单且稳定，若语法频繁变化或过于复杂（如包含嵌套循环、复杂控制流），建议使用解析器生成工具（如ANTLR）。

3.需要动态扩展语法规则，通过新增解释器类即可支持新语法，避免修改核心解析逻辑。

举例

以下是以关系表达式计算为例的实现，其中字母对应数值为所在字母表的位置（如A=1，B=2）：

// 上下文类（保存变量值）
class Context {
    private Map<String, Integer> variables = new HashMap<>();

    public void setValue(String variable, int value) {
        variables.put(variable, value);
    }

    public int getValue(String variable) {
        return variables.get(variable);
    }
}

// 数值表达式接口
interface NumericExpression {
    int evaluate(Context context);
}

// 变量表达式（终结符）
class Variable implements NumericExpression {
    private String name;
    public Variable(String name) { this.name = name; }

    @Override
    public int evaluate(Context context) {
        return context.getValue(name);
    }
}

// 加法表达式（非终结符）
class Add implements NumericExpression {
    private NumericExpression left, right;
    public Add(NumericExpression l, NumericExpression r) {
        this.left = l;
        this.right = r;
    }

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

// 布尔表达式接口
interface BooleanExpression {
    boolean evaluate(Context context);
}

// 大于比较表达式
class GreaterThan implements BooleanExpression {
    private NumericExpression left, right;
    public GreaterThan(NumericExpression l, NumericExpression r) {
        this.left = l;
        this.right = r;
    }

    @Override
    public boolean evaluate(Context context) {
        return left.evaluate(context) > right.evaluate(context);
    }
}

// 等于比较表达式
class Equal implements BooleanExpression {
    private NumericExpression left, right;
    public Equal(NumericExpression l, NumericExpression r) {
        this.left = l;
        this.right = r;
    }

    @Override
    public boolean evaluate(Context context) {
        return left.evaluate(context) == right.evaluate(context);
    }
}

// 测试类
public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Context context = new Context();
        context.setValue("A", 1);
        context.setValue("B", 2);
        context.setValue("C", 3);
        context.setValue("D", 4);

        // 表达式：A + B = C → 1 + 2 = 3
        BooleanExpression expr1 = new Equal(
            new Add(new Variable("A"), new Variable("B")),
            new Variable("C")
        );
        System.out.println(expr1.evaluate(context)); // true

        // 表达式：B < C → 2 < 3
        BooleanExpression expr2 = new GreaterThan(
            new Variable("C"), new Variable("B")
        );
        System.out.println(expr2.evaluate(context)); // true

        // 表达式：A + B > D → 3 > 4
        BooleanExpression expr3 = new GreaterThan(
            new Add(new Variable("A"), new Variable("B")),
            new Variable("D")
        );
        System.out.println(expr3.evaluate(context)); // false
    }
}

反例

若无需灵活扩展语法，可通过硬编码解析表达式字符串实现：

// 简单表达式解析器（反例）
class SimpleEvaluator {
    public static boolean evaluate(String expr, Context context) {
        // 仅支持单一比较符，解析逻辑硬编码
        String[] parts = expr.split(">|<|==");
        if (parts.length != 2) throw new IllegalArgumentException();

        int leftVal = parseArithmetic(parts[0].trim(), context);
        int rightVal = parseArithmetic(parts[1].trim(), context);

        if (expr.contains(">")) return leftVal > rightVal;
        else if (expr.contains("<")) return leftVal < rightVal;
        else if (expr.contains("==")) return leftVal == rightVal;
        else throw new IllegalArgumentException();
    }

    private static int parseArithmetic(String expr, Context context) {
        if (expr.contains("+")) {
            String[] vars = expr.split("\\+");
            return context.getValue(vars[0].trim()) + context.getValue(vars[1].trim());
        }
        return context.getValue(expr.trim());
    }
}

// 使用示例
boolean result = SimpleEvaluator.evaluate("A + B == C", context);

但存在以下问题：

1.代码耦合度高，新增语法（如乘法、嵌套表达式）需修改核心解析逻辑。

2.难以处理复杂表达式（如(A + B) * C > D），硬编码解析逻辑无法支持嵌套结构。

3.维护困难，语法规则变化时需频繁修改解析代码，容易引入错误。

原理

解释器模式通过定义语言的语法规则，将表达式分解为终结符（如变量、数值）和非终结符（如加法、比较操作），通过递归组合构建抽象语法树（AST）。解释器逐层遍历AST，执行对应操作（如计算数值、比较大小），最终完成表达式的解释执行。

缺点

1.类数量膨胀，复杂语法会导致解释器类过多，难以维护。

2.效率较低，递归解释过程可能影响性能（尤其对于深层嵌套表达式）。

总结

解释器模式适用于需要解释特定领域简单且稳定语言的场景，通过分解语法单元和递归组合实现灵活扩展。其优势在于解耦语法解析与业务逻辑，符合开闭原则；但需权衡类膨胀和性能问题，复杂语法场景建议结合解析器生成工具使用。