Java设计模式解释器模式

Java设计模式中的解释器模式（Interpreter Pattern）是一种行为型设计模式，它定义了一种语言文法并定义该语言文法的解释器，用于解释语言中的表达式。

在解释器模式中，通常会定义一个抽象表达式类，具体表达式类继承抽象表达式类，并实现表达式的解释方法。另外，还会定义一个环境类，用于保存解释器的上下文信息。

解释器模式常用于编译器、解析器等场景，例如编译器中的词法分析器和语法分析器。

下面是一个简单的Java代码示例，展示了解释器模式的基本结构：

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

// 终结符表达式类
class TerminalExpression extends Expression {
    private String data;

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

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

// 非终结符表达式类
class OrExpression extends Expression {
    private Expression expr1 = null;
    private Expression expr2 = null;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

// 环境类
class Context {
    private String context;

    public Context(String context) {
        this.context = context;
    }

    public String getContext() {
        return context;
    }

    public void setContext(String context) {
        this.context = context;
    }
}

// 客户端代码
public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Expression terminal1 = new TerminalExpression("Hello");
        Expression terminal2 = new TerminalExpression("World");
        Expression or = new OrExpression(terminal1, terminal2);

        Context context1 = new Context("Hello World!");
        Context context2 = new Context("Goodbye World!");

        System.out.println(or.interpret(context1.getContext())); // true
        System.out.println(or.interpret(context2.getContext())); // true
    }
}
           

在这个示例中，Expression是抽象表达式类，TerminalExpression和OrExpression是具体表达式类。TerminalExpression表示终结符表达式，OrExpression表示非终结符表达式。

Context是环境类，用于保存解释器的上下文信息。

客户端代码创建了一个OrExpression对象，并将其解释应用于两个不同的上下文（context1和context2），输出结果表明解释器能够正确地解释表达式。