解释器模式（Interpreter Pattern）

解释器模式是一种行为设计模式，它定义了一个语言的文法，并且设计一个解释器来解释该语言中的句子。它允许你构建一个解释器，解释特定语法的语句。

结构

• 抽象表达式（Abstract Expression）： 声明一个抽象的解释操作，所有具体表达式类都是它的子类。

public interface Expression {
    boolean interpret(String context);
}

• 具体表达式（Concrete Expression）： 实现抽象表达式接口，实现解释操作。

public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

public class OrExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public OrExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) || expression2.interpret(context);
    }
}

public class AndExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) && expression2.interpret(context);
    }
}

• 上下文（Context）： 包含解释器之外的一些全局信息。

优点和缺点

优点：

1. 灵活性： 可以轻松地改变和扩展文法，因为每个文法规则都可以表示为一个类。
2. 易于实现文法： 解释器模式提供了一种简洁的方式来实现文法，每个文法规则都可以被映射为一个类，易于理解和维护。

缺点：

1. 复杂度增加： 对于复杂的文法规则，可能需要创建大量的类来表示各种组合，导致类的数量急剧增加，增加了系统的复杂性。
2. 性能问题： 在解释器模式中，解释器对文法规则的解释是递归的，可能会导致性能问题。

示例

以下是一个解释器模式的示例，模拟了一个简单的规则解释器，判断一个字符串是否满足给定规则。规则包括AND（&）和OR（|）运算。

// 抽象表达式
public interface Expression {
    boolean interpret(String context);
}

// 终端表达式
public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

// 非终端表达式 - AND表达式
public class AndExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) && expression2.interpret(context);
    }
}

// 非终端表达式 - OR表达式
public class OrExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public OrExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) || expression2.interpret(context);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Expression person1 = new TerminalExpression("Alice");
        Expression person2 = new TerminalExpression("Bob");
        Expression aliceAndBob = new AndExpression(person1, person2);

        Expression person3 = new TerminalExpression("Charlie");
        Expression aliceOrBobAndCharlie = new OrExpression(aliceAndBob, person3);

        System.out.println(aliceOrBobAndCharlie.interpret("Alice"));    // 输出：true
        System.out.println(aliceOrBobAndCharlie.interpret("Bob"));      // 输出：true
        System.out.println(aliceOrBobAndCharlie.interpret("Charlie"));  // 输出：true
        System.out.println(aliceOrBobAndCharlie.interpret("David"));    // 输出：false
    }
}

在这个示例中，Expression 接口定义了解释器的基本操作。TerminalExpression 表示终端表达式，它可以判断一个字符串是否包含特定的文本。AndExpression 和 OrExpression 分别表示AND和OR表达式，它们是非终端表达式，可以组合多个终端表达式或者其他非终端表达式。客户端代码创建了一些终端表达式，并通过AND和OR运算组合这些表达式，实现了一定的文法规则。