解释器模式

字数: 0 字 时长: 0 分钟

简介

解释器模式（Interpreter Pattern）的核心思想是：为特定类型的语言提供解释执行的方法。适合用户自定义表达式配置、DSL、表达式解析等场景。

基本结构

• 抽象表达式：定义所有解释器的通用接口，负责解释和计算表达式
• 终结符表达式：实现抽象表达式的接口，表示具体的语法元素，这些元素是无法再分解的最小单位
• 非终结符表达式：与终结符表达式不同，它们表示语言中的组合元素，可以包含子元素
• 上下文：包含解释过程的一些全局信息，比如变量的值

实现示例

实现如 5 + (10 - 3) * 2 的数学表达式解析器：

// 1. 抽象表达式
interface MathExpression {
    int interpret(Context context);
}

// 2. 终结符表达式: 数字
class NumberExpression implements MathExpression {
    private final int number;
    public NumberExpression(int number) {
        this.number = number;
    }
    @Override
    public int interpret(Context context) {
        return number;  // 直接返回数字值
    }
}

// 3. 终结符表达式: 变量
class VariableExpression implements MathExpression {
    private final String variableName;
    public VariableExpression(String name) {
        this.variableName = name;
    }
    @Override
    public int interpret(Context context) {
        return context.getValue(variableName);  // 从上下文获取变量值
    }
}

// 4. 非终结符表达式: 加法
class AddExpression implements MathExpression {
    private final MathExpression left;
    private final MathExpression right;
    public AddExpression(MathExpression left, MathExpression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

// 5. 非终结符表达式: 乘法
class MultiplyExpression implements MathExpression {
    // 实现类似AddExpression
}

// 6. 非终结符表达式: 括号（优先权实现）
class GroupExpression implements MathExpression {
    private final MathExpression expression;
    public GroupExpression(MathExpression exp) {
        this.expression = exp;
    }
    @Override
    public int interpret(Context context) {
        return expression.interpret(context); // 优先计算括号内表达式
    }
}

// 7. 上下文环境（存储变量）
class Context {
    private final HashMap<String, Integer> variables = new HashMap<>();
    public void setVariable(String name, int value) {
        variables.put(name, value);
    }
    public int getValue(String name) {
        return variables.getOrDefault(name, 0);
    }
}

// 8. 语法解析器（核心）
class ExpressionParser {
    public MathExpression parse(String input) {
        // 语法解析逻辑...
        // 返回完整的表达式树
    }
}

// 9. 客户端使用
public class InterpreterDemo {
    public static void main(String[] args) {
        // 构建上下文（设置变量）
        Context context = new Context();
        context.setVariable("x", 5);
        context.setVariable("y", 10);
        // 手动构建语法树: (x + 2) * (y - 3)
        MathExpression expr = new MultiplyExpression(
            new GroupExpression(
                new AddExpression(
                    new VariableExpression("x"), 
                    new NumberExpression(2)
                )
            ),
            new GroupExpression(
                new AddExpression(
                    new VariableExpression("y"),
                    new NumberExpression(-3) // 减法特例
                )
            )
        );
        int result = expr.interpret(context);
        System.out.println("(x+2)*(y-3) = " + result); // 输出: (5+2)*(10-3)=7*7=49
        // 使用解析器动态构建
        ExpressionParser parser = new ExpressionParser();
        MathExpression parsedExpr = parser.parse("5 + (10 - 3) * 2");
        int result2 = parsedExpr.interpret(new Context());
        System.out.println("5 + (10-3)*2 = " + result2); // 输出: 5 + 7*2 = 19
    }
}