设计模式(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;
    }

    @Override
    public 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;
    }

    @Override
    public 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));
    }
}