【设计模式】解释器模式

解释器模式（Interpreter Pattern）

概念：

· 一种行为型设计模式；

· 核心思想是将文法规则定义为类的层次结构；

· 它把语言的语法规则封装成对象，通过对象之间的组合完成解释的过程；

UML结构：

+---------------------+
|    IExpression      | <<interface>>
+---------------------+
| +Interpret(): bool  |
+---------------------+
           ▲
           |
    -----------------------------
    |            |             |
+----------------+ +----------------+ +----------------+ +----------------+
| BoolExpression | | AndExpression  | | OrExpression   | | NotExpression  |
+----------------+ +----------------+ +----------------+ +----------------+
| -_val: bool    | | -_left:IExpression | -_left:IExpression | -_expression:IExpression |
|                | | -_right:IExpression| -_right:IExpression|                     |
+----------------+ +----------------+ +----------------+ +----------------+
| +Interpret()   | | +Interpret()       | +Interpret()       | +Interpret()       |
+----------------+ +----------------+ +----------------+ +----------------+

代码示例：

/// <summary>
/// 解释器接口类
/// </summary>
public interface IExpression
{   
    /// <summary>
    /// 解释方法
    /// </summary>
    /// <returns>返回值</returns>
    bool Interpret();
}

/// <summary>
/// 终端解释器
/// </summary>
public class BoolExpression : IExpression
{
    private bool _val;

    public BoolExpression(bool val)
    {
        this._val = val;
    }

    public bool Interpret()
    {
        return _val;
    }
}

/// <summary>
/// 非终端解释器（与操作）
/// </summary>
public class AndExpression : IExpression
{
    public IExpression _leftExpression;
    public IExpression _rightExpression;

    public AndExpression(IExpression leftExpression,
                        IExpression rightExpression)
    {
        this._leftExpression = leftExpression;
        this._rightExpression = rightExpression;
    }

    public bool Interpret()
    {
        return _leftExpression.Interpret() && _rightExpression.Interpret();
    }
}

/// <summary>
/// 非终端解释器（或操作）
/// </summary>
public class OrExpression : IExpression
{
    public IExpression _leftExpression;
    public IExpression _rightExpression;

    public OrExpression(IExpression leftExpression,
                        IExpression rightExpression)
    {
        this._leftExpression = leftExpression;
        this._rightExpression = rightExpression;
    }

    public bool Interpret()
    {
        return _leftExpression.Interpret() || _rightExpression.Interpret();
    }
}

/// <summary>
/// 非终端解释器（非操作）
/// </summary>
public class NotExpression : IExpression
{
    public IExpression _expression;

    public NotExpression(IExpression expression)
    {
        this._expression = _expression;
    }

    public bool Interpret()
    {
        return !_expression.Interpret();
    }
}

/// <summary>
/// 客户端
/// </summary>
public class Client
{
    public static void Main()
    {
        IExpression trueExpression = new BoolExpression(true);
        IExpression falseExpression = new BoolExpression(false);

        IExpression addExpression = new AndExpression(trueExpression, falseExpression);
        IExpression orExpression = new OrExpression(trueExpression, falseExpression);
        IExpression notExpression = new NotExpression(trueExpression);

        addExpression.Interpret();
        orExpression.Interpret();
        notExpression.Interpret();
    }
}

特点：
优点：

· 易于扩展：新增语法规则即新增类，不影响现有代码，符合开闭原则；

· 文法结构清晰：代码结构与文法结构相对应，便于维护和理解；

· 客户端可以自行组合表达式；
缺点：

· 文法的增多会导致类的增多，从而增加了系统的复杂度；

· 解释器的递归调用使得性能的需求增大；

适用场景：

· 问题可以用树形结构表示，则容易将每个语法规则封装成类；

· 当有一种语言需要解释执行，并且语法相对稳定；

· 当希望客户端能够方便地组合不同的表达式进行解释；

举例场景：

· SQL 解析器、正则表达式解释器；

· 计算器的计算表达式的解析；

· 配置文件和脚本语言的解释器；