介绍

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

主要解决：对于一些固定文法构建一个解释句子的解释器。

何时使用：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

如何解决：构建语法树，定义终结符与非终结符。

关键代码：构建环境类，包含解释器之外的一些全局信息，一般是 HashMap。

应用实例：编译器、运算表达式计算。

优点： 1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。

缺点： 1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模式采用递归调用方法。

 

代码实现

public class InterpreterMode {
    //制定匹配规则
    public  static Expression getOrExpression(){
        MainInterpreter interpreter = new MainInterpreter("C语言");
        MainInterpreter mainInterpreter = new MainInterpreter("good");
        return new OrExpression(interpreter,mainInterpreter);
    }
    public  static Expression getAndExpression(){
        MainInterpreter interpreter = new MainInterpreter("JAVA");
        MainInterpreter mainInterpreter = new MainInterpreter("世界上最好的语言");
        return new AndExpression(interpreter,mainInterpreter);
    }
    public static void main(String[] args) {
        Expression andExpression = getAndExpression();
        Expression orExpression = getOrExpression();
        System.out.println("Java是世界上最好的语言："+andExpression.interpret("JAVA:世界上最好的语言"));
        System.out.println("C是个不错的语言："+orExpression.interpret("good"));
    }
}

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

class MainInterpreter implements Expression {
    private String data;

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

    //是否匹配内容
    @Override
    public boolean interpret(String context) {
        if (context.contains(data)) {
            return true;
        }
        return false;
    }
}

class OrExpression implements Expression {
    private Expression ex1;
    private Expression ex2;

    public OrExpression(Expression ex1, Expression ex2) {
        this.ex1 = ex1;
        this.ex2 = ex2;
    }

    @Override
    public boolean interpret(String context) {
        return ex1.interpret(context)||ex2.interpret(context);
    }
}
class AndExpression implements Expression {
    private Expression ex1;
    private Expression ex2;

    public AndExpression(Expression ex1, Expression ex2) {
        this.ex1 = ex1;
        this.ex2 = ex2;
    }

    @Override
    public boolean interpret(String context) {
        return ex1.interpret(context)&&ex2.interpret(context);
    }
}