解释器模式

解释器模式

什么是解释器模式

解释器模式(interpreter).,给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子

• 如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题,例如:正则表达式

通过示例了解解释器模式

解释器模式（Interpreter Pattern）是一种行为设计模式，它提供了一种方式来表示语言的语法，并为解析这些表达式提供了解释器。以下是一个简单的Java解释器模式示例，用于计算简单的数学表达式：

首先，我们需要定义一个Expression接口，它是所有解释器类的基类：

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

接下来，创建一个Context类，它存储了变量和常量：

public class Context {
    private Map<String, Integer> variables = new HashMap<>();

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

    public int getVariable(String variable) {
        return variables.getOrDefault(variable, 0);
    }
}

现在，我们为每种运算符和数字创建一个解释器类：

1.TerminalExpression表示数字：

public class TerminalExpression implements Expression {
    private int number;

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

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

2.VariableExpression表示变量：

public class VariableExpression implements Expression {
    private String variable;

    public VariableExpression(String variable) {
        this.variable = variable;
    }

    @Override
    public int interpret(Context context) {
        return context.getVariable(variable);
    }
}

3.AddExpression表示加法：

public class AddExpression implements Expression {
    private Expression left, 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);
    }
}

4.SubtractExpression表示减法：

public class SubtractExpression implements Expression {
    private Expression left, right;

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

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

最后，我们创建一个ExpressionParser类来解析输入的字符串并构建解释器树：

public class ExpressionParser {
    public static Expression parse(String expression) {
        String[] parts = expression.split(" ");
        if (parts.length == 1) {
            try {
                return new TerminalExpression(Integer.parseInt(parts[0]));
            } catch (NumberFormatException e) {
                return new VariableExpression(parts[0]);
            }
        } else if (parts[1].equals("+")) {
            return new AddExpression(parse(parts[0]), parse(parts[2]));
        } else if (parts[1].equals("-")) {
            return new SubtractExpression(parse(parts[0]), parse(parts[2]));
        } else {
            throw new IllegalArgumentException("Invalid expression");
        }
    }
}

现在，我们可以使用这些类来解析和计算表达式：

public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Context context = new Context();
        context.setVariable("x", 5);

        Expression expression = ExpressionParser.parse("x + 3 * 2");
        System.out.println(expression.interpret(context)); // 输出：11

        expression = ExpressionParser.parse("5 - 2 * x");
        System.out.println(expression.interpret(context)); // 输出：-5
    }
}

在这个例子中，解释器模式允许我们动态地构建和解析简单的数学表达式，同时也易于扩展以支持更多的运算符和表达式类型。