解释器模式（Interpreter Pattern）

1. 什么是解释器模式？

解释器模式是一种行为型设计模式，它定义了一个语言的语法表示，并定义一个解释器来解释该语言中的句子。换句话说，解释器模式用于构建一个解释器，使其能够解释特定上下文中的语言。

解释器模式通常用于设计编译器、解释器、表达式计算引擎等系统，或者用于构建简单的领域特定语言(DSL)。

2. 为什么需要解释器模式？

在以下情况下，解释器模式特别有用：

1. 需要解释一种简单语言：当需要为简单语言、表达式或语句创建解释器时
2. 语法规则简单：当语法规则相对简单，并且可以用类层次结构表示时
3. 效率不是关键问题：当解释过程的效率不是主要考虑因素时
4. 需要频繁更改或扩展语法：当语法规则可能需要经常更改或扩展时

3. 解释器模式的核心概念

解释器模式涉及以下核心概念：

1. 抽象表达式（Abstract Expression）：定义解释操作的接口
2. 终结符表达式（Terminal Expression）：实现与文法中的终结符相关的解释操作
3. 非终结符表达式（Non-terminal Expression）：对应文法中的非终结符，通常包含其他表达式
4. 上下文（Context）：包含解释器之外的全局信息
5. 客户端（Client）：构建抽象语法树并调用解释操作

4. 解释器模式的结构

解释器模式的UML类图如下：

+----------------+      +---------------------+
| AbstractExpression    | Context             |
+----------------+      +---------------------+
| interpret()    |      | ...                 |
+----------------+      +---------------------+
       ^
       |
+------+------+
|             |
+----------------+      +----------------+
| TerminalExpression    | NonTerminalExpression
+----------------+      +----------------+
| interpret()    |      | interpret()    |
+----------------+      +----------------+
                        | expression1    |
                        | expression2    |
                        +----------------+

5. 解释器模式的基本实现

简单算术表达式解释器

下面是一个简单的算术表达式解释器，用于计算诸如"2 + 3"、"5 - 1"等简单表达式。

首先，我们定义抽象表达式接口：

// 抽象表达式
interface Expression {
   
    int interpret();
}

然后，我们实现终结符表达式（数字）：

// 终结符表达式 - 数字
class NumberExpression implements Expression {
   
    private int number;
    
    public NumberExpression(int number) {
   
        this.number = number;
    }
    
    @Override
    public int interpret() {
   
        return number;
    }
}

接着，我们实现非终结符表达式（加法和减法）：

// 非终结符表达式 - 加法
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() {
   
        return left.interpret() + right.interpret();
    }
}

// 非终结符表达式 - 减法
class SubtractExpression implements Expression {
   
    private Expression left;
    private Expression right;
    
    public SubtractExpression(Expression left, Expression right) {
   
        this.left = left;
        this.right = right;
    }
    
    @Override
    public int interpret() {
   
        return left.interpret() - right.interpret();
    }
}

最后，我们创建一个简单的解析器，将字符串表达式解析为语法树：

// 解析器
class Parser {
   
    public Expression parse(String expression) {
   
        String[] tokens = expression.split(" ");
        if (tokens.length != 3) {
   
            throw new IllegalArgumentException("无效表达式");
        }
        
        Expression left = new NumberExpression(Integer.parseInt(tokens[0]));
        Expression right = new NumberExpression(Integer.parseInt(tokens[2]));
        
        switch (tokens[1]) {
   
            case "+":
                return new AddExpression(left, right);
            case "-":
                return new SubtractExpression(left, right);
            default:
                throw new IllegalArgumentException("不支持的运算符: " + tokens[1]);
        }
    }
}

现在，我们可以使用这个解释器计算简单的表达式：

public class InterpreterPatternDemo {
   
    public static void main(String[] args) {
   
        String expression1 = "2 + 3";
        String expression2 = "5 - 1";
        
        Parser parser = new Parser();
        
        Expression exp1 = parser.parse(expression1);
        System.out.println(expression1 + " = " + exp1.interpret()); // 输出: 2 + 3 = 5
        
        Expression exp2 = parser.parse(expression2);
        System.out.println(expression2 + " = " + exp2.interpret()); // 输出: 5 - 1 = 4
    }
}

输出结果：

2 + 3 = 5
5 - 1 = 4

6. 解释器模式的进阶实现

扩展算术表达式解释器

我们可以扩展前面的例子，以支持更复杂的表达式，包括乘法和除法：

// 非终结符表达式 - 乘法
class MultiplyExpression implements Expression {
   
    private Expression left;
    private Expression right;
    
    public MultiplyExpression(Expression left, Expression right) {
   
        this.left = left;
        this.right = right;
    }
    
    @Override
    public int interpret() {
   
        return left.interpret() * right.interpret();
    }
}

// 非终结符表达式 - 除法
class DivideExpression implements Expression {
   
    private Expression left;
    private Expression right;
    
    public DivideExpression(Expression left, Expression right) {
   
        this.left = left;
        this.right = right;
    }
    
    @Override
    public int interpret()