设计模式(022)行为型之解释器模式

解释器模式是一种行为型设计模式，用于定义一种语言的文法，并且在该语言中解释句子的意义。这种模式通常用于实现编程语言解释器、正则表达式引擎等场景。
在解释器模式中，主要有以下几个角色：
① 抽象表达式（AbstractExpression）：定义了解释器的接口，包含一个 `interpret` 方法用于解释句子。
② 终结符表达式（TerminalExpression）：实现了抽象表达式接口，代表文法中的终结符，比如变量或者常量。
③ 非终结符表达式（NonterminalExpression）：实现了抽象表达式接口，代表文法中的非终结符，通常是由终结符表达式组成的组合。
④ 上下文环境（Context）：包含了解释器解释的上下文信息，可能影响解释的结果。
⑤ 客户端（Client）：构建待解释的语句，并将其传递给解释器进行解释。
解释器模式通过组合表达式来解释句子，将复杂的语法规则分解成简单的表达式，然后递归地解释每个表达式，最终得到结果。

1、场景设计

实现场景：使用解释器模式模拟一个简单的布尔表达式。

2、C++实现

模拟了一个简单的布尔表达式解释器。`Context` 类表示上下文环境，存储了变量的值。`Expression` 是抽象表达式类，定义了解释器的接口。`TerminalExpression` 是终结符表达式类，表示单个变量的值。`OrExpression` 是非终结符表达式类，表示两个表达式的逻辑或操作。在 `main` 函数中，我们设置了变量 A 和 B 的值，并构建了一个逻辑或表达式，最后对该表达式进行解释。

#include <iostream>
#include <unordered_map>
#include <string>// 上下文环境类
class Context {private:std::unordered_map<std::string, bool> variables;public:void setVariable(const std::string& name, bool value) {variables[name] = value;}bool getVariable(const std::string& name) {return variables[name];}
};// 抽象表达式类
class Expression {public:virtual bool interpret(Context& context) = 0;
};// 终结符表达式类
class TerminalExpression : public Expression {private:std::string variable;public:TerminalExpression(const std::string& variable) : variable(variable) {}bool interpret(Context& context) override {return context.getVariable(variable);}
};// 非终结符表达式类
class OrExpression : public Expression {private:Expression* expression1;Expression* expression2;public:OrExpression(Expression* expr1, Expression* expr2) : expression1(expr1), expression2(expr2) {}bool interpret(Context& context) override {return expression1->interpret(context) || expression2->interpret(context);}~OrExpression() {delete expression1;delete expression2;}
};// 客户端代码
int main() {Context context;context.setVariable("A", true);context.setVariable("B", false);Expression* expression = new OrExpression(new TerminalExpression("A"), new TerminalExpression("B"));std::cout << "A OR B is: " << expression->interpret(context) << std::endl;delete expression;return 0;
}

3、Java实现

模拟了一个简单的布尔表达式解释器。`Context` 类表示上下文环境，存储了变量的值。`Expression` 是抽象表达式接口，定义了解释器的方法。`TerminalExpression` 是终结符表达式类，表示单个变量的值。`OrExpression` 是非终结符表达式类，表示两个表达式的逻辑或操作。在 `main` 方法中，我们设置了变量 A 和 B 的值，并构建了一个逻辑或表达式，最后对该表达式进行解释。

package behavioralpattern.interpreter;import java.util.HashMap;
import java.util.Map;// 上下文环境类
class Context {private Map<String, Boolean> variables = new HashMap<>();public void setVariable(String name, boolean value) {variables.put(name, value);}public boolean getVariable(String name) {return variables.getOrDefault(name, false);}
}// 抽象表达式类
interface Expression {boolean interpret(Context context);
}// 终结符表达式类
class TerminalExpression implements Expression {private String variable;public TerminalExpression(String variable) {this.variable = variable;}@Overridepublic boolean interpret(Context context) {return context.getVariable(variable);}
}// 非终结符表达式类
class OrExpression implements Expression {private Expression expression1;private Expression expression2;public OrExpression(Expression expression1, Expression expression2) {this.expression1 = expression1;this.expression2 = expression2;}@Overridepublic boolean interpret(Context context) {return expression1.interpret(context) || expression2.interpret(context);}
}public class InterpreterDemo {public static void main(String[] args) {Context context = new Context();context.setVariable("A", true);context.setVariable("B", false);Expression expression = new OrExpression(new TerminalExpression("A"), new TerminalExpression("B"));System.out.println("A OR B is: " + expression.interpret(context));}
}