一、白话

  解释器模式，就是定义一种语言，并提供一个解释器。定义的语句都可以被解释器解释。例如数学中，我们定义 数字，定义了加法，数字和加法组合成一个语言公式解释器，1+1=2,这样，主要是数字和加法的组合语言，我都能用加法公式解释器解释。我现在定义一个 名词，使用包含来解释。在此基础上，又定义一个组合名词，使用并且并且来解释。

二、定义

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

抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。

三、示例

// 抽象表达式-定义解释器
public interface Expression {
    public boolean interpret(String data);
}

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

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

    @Override
    public boolean interpret(String msg) {
        return msg.contains(data);
    }
}

// 非总结符表达式
public class AndExpression implements Expression {
    Expression expr1;
    Expression expr2;

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

    @Override
    public boolean interpret(String data) {
        return expr1.interpret(data) && expr2.interpret(data);
    }
}

// 非总结符表达式
public class OrExpression implements Expression {
    Expression expr1;
    Expression expr2;

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

    @Override
    public boolean interpret(String data) {
        return expr1.interpret(data) || expr2.interpret(data);
    }
}

// 环境角色
public class Context {
    // 定义 是否包含苹果或者香蕉
    public static Expression hasAppleExpression() {
        Expression apple = new TerminalExpression("apple");
        Expression banana = new TerminalExpression("banana");
        return new OrExpression(apple, banana);
    }

    // 定义 是否是红色苹果
    public static Expression isRedAppleExpression() {
        Expression apple = new TerminalExpression("apple");
        Expression red = new TerminalExpression("red");
        return new AndExpression(apple, red);
    }
}

public class InterpreterApplication {
    // 客户端使用
    public static void main(String[] args) {
        Expression hasAppleExpression = Context.hasAppleExpression();
        Expression redAppleExpression = Context.isRedAppleExpression();

        System.out.println("has apple ? " + hasAppleExpression.interpret("apple"));
        System.out.println("is red apple ? " + redAppleExpression.interpret("red apple"));

        System.out.println("has apple ? " + hasAppleExpression.interpret("pear"));
        System.out.println("is red apple ? " + redAppleExpression.interpret("blue apple"));
    }
}

  输出结果示例：

   has apple ? true
   is red apple ? true
   has apple ? false
   is red apple ? false

四、总结

  特点： 1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。 4、对于复杂的文法比较难维护。 5、解释器模式会引起类膨胀。