解释器模式属于行为型模式；指给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。

解释器模式的UML类图如下所示：

由上图可知，解释器模式涉及到抽象表达式（Abstract Expression）角色、终结符表达式（Terminal Expression）角色、非终结符表达式（Nonterminal Expression）角色、环境（Context）角色、客户端（Client）角色等五种角色：

1. 抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
2. 终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
3. 非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
4. 环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
5. 客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

模拟java语言对布尔表达式操作的例子

例子的UML类图:

抽象表达式角色：

package com.charon.interpreter;

/**
 * @author ：charon
 * @description： 这个抽象类代表终结类和非终结类的抽象化，其中终结类和非终结类的语法如下：
 *      Expression ::= Expression AND Expression
 *                   | Expression OR Expression
 *                   | NOT Expression
 *                   | Variable (非空白字符串)
 *                   | Constant (true | false)
 * @date ： 2022/4/7 8:32
 * @version: 1.0
 */
public abstract class Expression {

    /**
     * 解释给定的任何一个表达式
     * @param context
     * @return
     */
    public abstract boolean interpret(Context context) throws IllegalAccessException;

    /**
     * 检验两个表达式在结构上是否相同
     * @param object
     * @return
     */
    @Override
    public abstract boolean equals(Object object);

    /**
     * 将表达式转换成字符串
     * @return
     */
    @Override
    public abstract String toString();
}

非终结符表达式角色：

package com.charon.interpreter;

/**
 * @author ：charon
 * @description： 逻辑与的操作 ，表示由两个布尔表达式通过逻辑与操作给出一个新的布尔表达式
 * @date ： 2022/4/7 10:12
 * @version: 1.0
 */
public class And extends Expression{

    private Expression left,right;

    public And(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean interpret(Context context) throws IllegalAccessException {
        return left.interpret(context) && right.interpret(context);
    }

    @Override
    public boolean equals(Object object) {
        if(object != null && object instanceof And){
            return this.left.equals(((And) object).left) && this.right.equals(((And) object).right);
        }
        return false;
    }

    @Override
    public String toString() {
        return "( " + left.toString() + " AND " + right.toString() + ")";
    }
}

package com.charon.interpreter;

/**
 * @author ：charon
 * @description： 逻辑或操作
 * @date ： 2022/4/7 18:03
 * @version: 1.0
 */
public class Or extends Expression{

    private Expression left,right;

    public Or(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean interpret(Context context) throws IllegalAccessException {
        return left.interpret(context) || right.interpret(context);
    }

    @Override
    public boolean equals(Object object) {
        if(object != null && object instanceof Or){
            return this.left.equals(((Or) object).left) && this.right.equals(((Or) object).right);
        }
        return false;
    }

    @Override
    public String toString() {
        return "( " + left.toString() + " OR " + right.toString() + ")";
    }
}

package com.charon.interpreter;

/**
 * @author ：charon
 * @description： 逻辑非的操作
 * @date ： 2022/4/7 10:12
 * @version: 1.0
 */
public class Not extends Expression{

    private Expression expression;

    public Not(Expression expression) {
        this.expression = expression;
    }

    @Override
    public boolean interpret(Context context) throws IllegalAccessException {
        return !expression.interpret(context);
    }

    @Override
    public boolean equals(Object object) {
        if(object != null && object instanceof Not){
            return this.expression.equals(((Not) object).expression);
        }
        return false;
    }

    @Override
    public String toString() {
        return "( not " + expression.toString() + ")";
    }
}

终结符表达式角色：

package com.charon.interpreter;

/**
 * @author ：charon
 * @description： 有名变量
 * @date ： 2022/4/7 8:43
 * @version: 1.0
 */
public class Variable extends Expression{

    private String name;

    public Variable(String name) {
        this.name = name;
    }

    @Override
    public boolean interpret(Context context) throws IllegalAccessException {
        return context.lookUp(this);
    }

    @Override
    public boolean equals(Object object) {
        if (object != null && object instanceof Variable){
            return this.name.equals(((Variable) object).name);
        }
        return false;
    }

    @Override
    public String toString() {
        return name;
    }
}

环境类角色：

package com.charon.interpreter;

import java.util.HashMap;
import java.util.Map;

/**
 * @author ：charon
 * @description： 环境类定义
 * @date ： 2022/4/7 8:38
 * @version: 1.0
 */
public class Context {

    private Map<Object,Object> map = new HashMap<>();

    /**
     *
     * @param variable
     * @param value
     */
    public void assign(Variable variable,boolean value){
        map.put(variable, value);
    }

    /**
     * 获取值
     * @param variable
     * @return
     */
    public boolean lookUp(Variable variable) throws IllegalAccessException {
        Boolean value = (Boolean) map.get(variable);
        if(value == null){
            throw new IllegalAccessException();
        }
        return  value.booleanValue();
    }
}

客户端角色：

package com.charon.interpreter;

/**
 * @author ：charon
 * @description：
 * @date ： 2022/4/7 8:31
 * @version: 1.0
 */
public class Client {

    public static void main(String[] args) throws IllegalAccessException {
        Context context = new Context();
        Variable x = new Variable("x");
        Variable y = new Variable("y");
        Constant constant = new Constant(true);
        context.assign(x,false);
        context.assign(y,true);
        Expression expression = new Or(new And(constant, x), new And(y, new Not(x)));
        System.out.println("x = " + x.interpret(context));
        System.out.println("y = " + y.interpret(context));
        System.out.println(expression + " = " + expression.interpret(context));
    }
}

打印：
    x = false
    y = true
    ( ( true AND x) OR ( y AND ( not x))) = true	

解释器模式的主要优点如下：

1. 扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
2. 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

解释器模式的主要缺点如下：

1. 执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。
2. 会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
3. 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

模式的应用场景

1. 当语言的文法较为简单，且执行效率不是关键问题时。

2. 当问题重复出现，且可以用一种简单的语言来进行表达时。

3. 当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。