行为型模式-策略模式的概述与实践

解释器模式是一种行为设计模式，用于解释语言或表达式。它定义了一种语言的语法，并提供了解释器来解释该语言中的表达式。以下是一个简单的 Java 示例，演示了解释器模式的用法：

import java.util.Map;
import java.util.Stack;
import java.util.HashMap;

// 抽象表达式类
interface Expression {
    int interpret(Map<String, Integer> context);
}

// 终结符表达式类
class Number implements Expression {
    private int number;

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

    public int interpret(Map<String, Integer> context) {
        return number;
    }
}

// 非终结符表达式类 - 加法
class Plus implements Expression {
    private Expression leftOperand;
    private Expression rightOperand;

    public Plus(Expression left, Expression right) {
        leftOperand = left;
        rightOperand = right;
    }

    public int interpret(Map<String, Integer> context) {
        return leftOperand.interpret(context) + rightOperand.interpret(context);
    }
}

// 非终结符表达式类 - 减法
class Minus implements Expression {
    private Expression leftOperand;
    private Expression rightOperand;

    public Minus(Expression left, Expression right) {
        leftOperand = left;
        rightOperand = right;
    }

    public int interpret(Map<String, Integer> context) {
        return leftOperand.interpret(context) - rightOperand.interpret(context);
    }
}

// 上下文类
class Context {
    private Map<String, Integer> variables = new HashMap<>();

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

    public int getVariable(String name) {
        return variables.get(name);
    }
}

// 客户端类
public class Main {
    public static void main(String[] args) {
        String expression = "a + b - c";
        Context context = new Context();
        context.setVariable("a", 10);
        context.setVariable("b", 5);
        context.setVariable("c", 2);

        Expression parsedExpression = parse(expression);
        int result = parsedExpression.interpret(context);
        System.out.println("Result: " + result); // Output: Result: 13
    }

    public static Expression parse(String expression) {
        Stack<Expression> stack = new Stack<>();

        for (String token : expression.split("\\s")) {
            if (token.equals("+")) {
                Expression right = stack.pop();
                Expression left = stack.pop();
                stack.push(new Plus(left, right));
            } else if (token.equals("-")) {
                Expression right = stack.pop();
                Expression left = stack.pop();
                stack.push(new Minus(left, right));
            } else {
                stack.push(new Number(Integer.parseInt(token)));
            }
        }

        return stack.pop();
    }
}

在这个示例中，我们首先定义了抽象表达式接口 Expression，它有一个 interpret 方法用于解释表达式。然后我们定义了终结符表达式类 Number 用于表示数字，以及非终结符表达式类 Plus 和 Minus 分别用于表示加法和减法操作。
Context 类表示解释器的上下文，包含了变量的值。Main 类作为客户端，定义了一个表达式字符串，并解析该表达式并进行求值。
解析过程在 parse 方法中进行，我们使用栈来构建表达式的语法树，遇到操作符时，弹出栈顶的两个表达式，并根据操作符构建相应的表达式节点，然后将新的表达式节点压入栈中。
最后，通过调用解释器的 interpret 方法，我们可以传入上下文对象来求解表达式的值。