设计模式 行为型模式 -- 解释器模式

Posted 2021-12-04 CodeJiao

1. 解释器模式

---

1.1 概述

如上图，设计一个软件用来进行加减计算。我们第一想法就是使用工具类，提供对应的加法和减法的工具方法。

分析：

• 上面的形式比较单一、有限，如果形式变化非常多，这就不符合要求，因为加法和减法运算，两个运算符与数值可以有无限种组合方式。比如 1+2+3+4+5、1+2+3-4等等。
• 显然，现在需要一种翻译识别机器，能够解析由数字以及 + - 符号构成的合法的运算序列。如果把运算符和数字都看作节点的话，能够逐个节点的进行读取解析运算，这就是解释器模式的思维。

---

1.2 定义

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

示例：

在解释器模式中，我们需要将待解决的问题，提取出规则，抽象为一种“语言”。比如加减法运算，规则为：由数值和±符号组成的合法序列，“1+3-2” 就是这种语言的句子。

---

1.3 文法（语法）规则

文法是用于描述语言的语法结构的形式规则。

expression ::= value | plus | minus // 表达式可以是一个value或者一个plus（加法）或者是一个minus（减法）
plus ::= expression ‘+’ expression // 加法是表达式用+相连
minus ::= expression ‘-’ expression // 减法是表达式用-相连
value ::= integer // value是一个整数

说明：

这里的符号“::=”表示“定义为”的意思，竖线 | 表示或，左右的其中一个，引号内为字符本身，引号外为语法。

上面规则描述为 ：

表达式可以是一个值，也可以是plus或者minus运算，而plus和minus又是由表达式结合运算符构成，值的类型为整型数。

---

1.4 抽象语法树

在计算机科学中，抽象语法树（AbstractSyntaxTree，AST），或简称语法树（Syntax tree），是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。

用树形来表示符合文法规则的句子。

---

1.5 结构

解释器模式包含以下主要角色:

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

---

1.6 【例】设计实现加减法的软件

类图如下：

代码实现：

AbstractExpression.java

package com.tian.interpreter;

/**
 * @version v1.0
 * @ClassName: AbstractExpression
 * @Description: 抽象表达式类
 */
public abstract class AbstractExpression {
    public abstract int interpret(Context context);
}

Plus.java

package com.tian.interpreter;

/**
 * @version v1.0
 * @ClassName: Plus
 * @Description: 加法表达式类：终结符表达式
 */
public class Plus extends AbstractExpression {

    //+号左边的表达式
    private final AbstractExpression left;
    //+号右边的表达式
    private final AbstractExpression right;

    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    public int interpret(Context context) {
        //将左边表达式的结果和右边表达式的结果进行相加
        return left.interpret(context) + right.interpret(context);
    }

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

Minus.java

package com.tian.interpreter;

/**
 * @version v1.0
 * @ClassName: Plus
 * @Description: 减法表达式类：终结符表达式
 */
public class Minus extends AbstractExpression {

    //-号左边的表达式
    private final AbstractExpression left;
    //-号右边的表达式
    private final AbstractExpression right;

    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    public int interpret(Context context) {
        //将左边表达式的结果和右边表达式的结果进行相减
        return left.interpret(context) - right.interpret(context);
    }

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

Variable.java

package com.tian.interpreter;

/**
 * @version v1.0
 * @ClassName: Variable
 * @Description: 封装变量的类：非终结符表达式
 */
public class Variable extends AbstractExpression {

    //声明存储变量名的成员变量
    private final String name;

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

    public int interpret(Context context) {
        //直接返回变量的值
        return context.getValue(this);
    }

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

Context.java

package com.tian.interpreter;

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

/**
 * @version v1.0
 * @ClassName: Context
 * @Description: 环境角色类
 */
public class Context {

    //定义一个map集合，用来存储变量及对应的值
    private Map<Variable, Integer> map = new HashMap<Variable, Integer>();

    //添加变量的功能
    public void assign(Variable var, Integer value) {
        map.put(var, value);
    }

    //根据变量获取对应的值
    public int getValue(Variable var) {
        return map.get(var);
    }
}

Client.java

package com.tian.interpreter;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: 客户端类
 */
public class Client {
    public static void main(String[] args) {
        //创建环境对象
        Context context = new Context();

        //创建多个变量对象
        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");
        Variable d = new Variable("d");

        //将变量存储到环境对象中
        context.assign(a, 1);
        context.assign(b, 2);
        context.assign(c, 3);
        context.assign(d, 4);

        //获取抽象语法树    a + b - c + d
        AbstractExpression expression = new Minus(a, new Minus(new Minus(b, c), d));

        //解释（计算）
        int result = expression.interpret(context);

        System.out.println(expression + " = " + result);
    }
}

运行结果：

---

1.7 优缺点分析：适用场景

---

1.7.1 优点

---

1.7.2 缺点

---

1.7.3 适用环境

---

---