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

4.3 解释器模式

1. 模式动机与定义

   • 模式动机
     • Java语言无法直接解释类似"1+2+3-4+1"这样的字符串
     • 定义一套文法规则来实现对这些语句的解释，即设计一个自定义语言
     • 基于现有的编程语言 -> 面向对象编程语言 -> 解释器模式
   • 模式定义
     • 解释器模式(Interpreter Pattern): 定义一个语言的文法，并且建立一个解释器来解释该语言中的句子。
     • 此处，“语言” 是指使用规定格式的语法的代码
     • 它是一种类行为模式

2. 模式结构与分析

   • 模式结构
     • 包含如下角色：
       • AbstractExpression:抽象表达式
       • TerminalExpression:终结符表达式
       • NonterminalExpression:非终结符表达式
       • Context:环境类
   • 模式分析

     • 是一种使用频率相对较低但学习难度相对较大的设计模式，用于描述如何使用面向对象语言构成一个简单的语言解释器

     • 能够加深对面向对象思想的理解，并且理解编程语言中文法规则的解释过程

     • 文法规则

       • 1 + 2 + 3 -4 + 1
         • expression ::= value|operation
         • operation ::= expression '+' expression | expression '-' expression
         • value ::= an integer //一个整数值
       • ::= 表示 定义为
       • ｜ 表示 或
       • { } 表示 组合
       • • 表示 出现0次或多次

     • 抽象语法树(AbstractSyntax Tree,AST)

       • 描述了如何构成一个复杂的句子，通过对抽象语法书的分析，可以识别出语言中的终结符类和非终结符类

     • 环境类Context

       • 用于存储一些全局信息，一般包含一个HashMap或ArrayList等类型的集合对象(也可以直接由HashMap等集合类充当环境类)，存储一系列公共信息，例如变量名与值的映射关系(Key/value)，用于在执行具体的解释操作时从中获取相关信息
       • 可以在环境类中增加一些所有表达式解释器都共有的功能，以减轻解释器的职责
       • 当系统无须提供全局公共信息时可以省略环境类，根据实际情况决定是否需要环境类

3. 模式实例与解析

4. 模式效果与应用

   • 模式优点

     • 易于改变和扩展文法
     • 可以方便地实现一个简单的语言
     • 实现文法较为容易(有自动生成工具)
     • 增加新的解释表达式较为方便

   • 模式缺点

     • 对于复杂文法难以维护
     • 执行效率较低

   • 模式应用

     • 可以将一个需要解释执行的语言中的句子表示为一颗抽象语法树
     • 一些重复出现的问题可以用一种简单的语言来进行表达
     • 一个语言的文法较为简单
     • 执行效率不是关键问题

interface Node {
    int interpret();
}

// 非终结符表达式类
abstract class SymbolNode implements Node {

    protected Node left;
    protected Node right;
    SymbolNode(Node left, Node right){
        this.left = left;
        this.right = right;
    }


}

//终结符表达式类
class ValueNode implements Node{
    private int value;
    public ValueNode(int value) {
        this.value = value;
        
    }
    public int interpret() {
        return this.value;
    }

}
//加法
class AddNode extends SymbolNode {

    AddNode(Node left, Node right){
        super(left,right);
    }
    @Override
    public int interpret() {
        // TODO Auto-generated method stub
        return super.left.interpret() + super.right.interpret();
    }

}
// 减法
class SubNode extends SymbolNode{
    SubNode(Node left, Node right){
        super(left, right);
    }
    @Override
    public int interpret() {
        // TODO Auto-generated method stub
        return super.left.interpret() - super.right.interpret();
    }

}

// 乘法
class MulNode extends SymbolNode {

    MulNode(Node left, Node right){
        super(left, right);
    }
    @Override
    public int interpret() {
        // TODO Auto-generated method stub
        return super.left.interpret() * super.right.interpret();
    }

}
// 除运算
class DivNode extends SymbolNode {

    public DivNode(Node left, Node right) {
        // TODO Auto-generated constructor stub
        super(left,right);
    }
    @Override
    public int interpret() {
        // TODO Auto-generated method stub
        return super.left.interpret() / super.right.interpret();
    }

}
// 模运算
class ModNode extends SymbolNode {

    ModNode(Node left, Node right){
        super(left, right);
    }
    @Override
    public int interpret() {
        // TODO Auto-generated method stub
        return super.left.interpret() % super.right.interpret();
    }

}
// 计算器类
class Calculator {
    
    private String statement;
    private Node node;
    
    
    public void build(String statement) {
        Node left = null;
        Node right = null;
        Stack stack = new Stack();
        
        String [] statementArr = statement.split(" ");
        
        for(int i = 0; i