解释器模式

场景引入：解释器模式用于描述如何构成一个简单的语言解释器，主要应用于使用面向对象语言开发的解释器的设计。当需要开发一个新的语言的时候可以考虑使用解释器模式

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表达式来解释语言中的句子

文法规则和抽象语法树

本文以加/减法解释器为例，每一个输入表达式（例如1+2+3-4+1）都是包含了3个语言单位，可以使用以下文法规则来定义：

expression :: = value | operation
operation :: = expression '+' expression | expression '-' expression
value :: = an integer        //一个整数值

该文法规则包含3条语句，第一条表示表达式的组成方式，其中value和operation是后面两个语言单位的定义，每一条语句所定义的字符串（如operation和value）称为语言构造成分或语言单位，符号“::=”是定义为的意思，其左边的语言单位通过右边来进行说明和定义，语言单位对应终结符表达式和非终结符表达式。例如本规则中的operation是非终结符表达式，它的组成元素仍可以是表达式，可以进一步分解，而value是终结符表达式，它的组成元素是最基本的语言单位，不能再进行分解。

抽象语法树可以直观的表示语言的构成，每一棵抽象语法树对应一个语言实例。例如加法/减法表达式语言中的语句“1+2+3-4+1”可以通过如图所示的抽象语法树来表示：

解释器模式结构

解释器模式包含以下4个角色：

（1）AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象解释操作，它是所有终结符和非终结符表达式的父类

（2）TerminalExpression（终结符表达式）：它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例

（3）NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式完成

（4）Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通过它临时存储了需要解释的语句

 解释器模式应用实例

1. 实例说明

某公司要开发一套简单的机器人控制程序，控制程序中包含一些简单的英文控制指令，每一个指令对应一个表达式，该表达式可以是简单的表达式也可以是复合表达式，每一个简单的表达式由移动方向（上：up、下：down、左：left、右：right），移动方式（移动：move、快速移动：run），移动距离（一个正整数），两个表达式可以通过与（and）连接形成复合表达式。控制指令示例：“down run 10 and left move 5”，则“向下快速移动10个单位再向左移动5个单位”；输入“up move 10”，则“向上移动10个单位”

2. 实例分析及类图

根据上述的需求描述用形式化语言表达的文法规则如下：

expression ::= direction action distance | composite        //表达式
composite ::= expression 'and' expression        　　　　　　 //复合表达式
direction ::= 'up' | 'down' | 'left' | 'right'           　 //移动方向
action ::= 'move' | 'run'                                  //移动方式
distance ::= an integer                                    //移动距离

3. 代码实例

package designpatterns.interpreter;

public abstract class AbstractNode {
    public abstract String interpret();
}

package designpatterns.interpreter;

public class AndNode extends AbstractNode {
    private AbstractNode left;        //And的左表达式
    private AbstractNode right;        //And的右表达式
    
    public AndNode(AbstractNode left, AbstractNode right) {
        this.left = left;
        this.right = right;
    }

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

package designpatterns.interpreter;

public class SentenceNode extends AbstractNode {
    private AbstractNode direction;
    private AbstractNode action;
    private AbstractNode distance;

    public SentenceNode(AbstractNode direction, AbstractNode action, AbstractNode distance) {
        super();
        this.direction = direction;
        this.action = action;
        this.distance = distance;
    }

    @Override
    public String interpret() {
        return direction.interpret() + action.interpret() + distance.interpret();
    }

}

package designpatterns.interpreter;

public class DirectionNode extends AbstractNode {
    private String direction;

    public DirectionNode(String direction) {
        super();
        this.direction = direction;
    }

    @Override
    public String interpret() {
        if(direction.equalsIgnoreCase("up")){
            return "向上";
        }
        else if(direction.equalsIgnoreCase("down")) {
            return "向下";
        }
        else if(direction.equalsIgnoreCase("left")) {
            return "向左";
        }
        else if(direction.equalsIgnoreCase("right")) {
            return "向右";
        }
        else{
            return "无效指令";
        }
    }
}

package designpatterns.interpreter;

public class ActionNode extends AbstractNode {
    private String action;
    
    public ActionNode(String action) {
        super();
        this.action = action;
    }
    
    @Override
    public String interpret() {
        if(action.equalsIgnoreCase("move")) {
            return "移动";
        }
        else if(action.equalsIgnoreCase("run")){
            return "快速移动";
        }
        else{
            return "无效指令";
        }
    }
}

package designpatterns.interpreter;

public class DistanceNode extends AbstractNode {
    private String distance;
    
    public DistanceNode(String distance) {
        super();
        this.distance = distance;
    }

    @Override
    public String interpret() {
        return this.distance;
    }
}

package designpatterns.interpreter;

import java.util.Stack;

public class InstructionHandler {
    private AbstractNode node;
    
    public void handle(String instruction){
        AbstractNode left = null,right = null;
        AbstractNode action = null,direction = null,distance = null;
        
        //声明一个栈对象用于存储抽象语法树
        Stack<AbstractNode> stack = new Stack<AbstractNode>();
        //以空格分割指令字符串
        String[] words = instruction.split(" ");
        for(int i = 0;i < words.length;i++) {
            /**
             * 本实例采用栈的方式处理指令，如果遇到and，将其后的3个单词作为3个终结
             * 表达式连成一个简单句子SentenceNode作为and的右表达式，而将从栈顶
             * 弹出的表达式作为and的左表达式，最后将新的and表达式压入栈中
             */
            if(words[i].equalsIgnoreCase("and")) {
                left = (AbstractNode)stack.pop();    //弹出栈顶表达式作为左表达式
                String word1 = words[++i];
                direction = new DirectionNode(word1);
                String word2 = words[++i];
                action = new ActionNode(word2);
                String word3 = words[++i];
                distance = new DistanceNode(word3);
                
                right = new SentenceNode(direction, action, distance);
                stack.push(new AndNode(left,right));    //将新表达式压入栈中
            }
            else{
                String word1 = words[i];
                direction = new DirectionNode(word1);
                String word2 = words[++i];
                action = new ActionNode(word2);
                String word3 = words[++i];
                distance = new DistanceNode(word3);
                left = new SentenceNode(direction, action, distance);
                stack.push(left);
            }
        }
        this.node = (AbstractNode)stack.pop();        //将全部表达式从栈中弹出
    }
    
    public String output(){
        String result = node.interpret();            //解释表达式
        return result;
    }
}

package designpatterns.interpreter;

public class Client {
    public static void main(String[] args) {
        String instruction = "down run 10 and up move 20";
        InstructionHandler handler = new InstructionHandler();
        handler.handle(instruction);
        
        String outputString;
        outputString = handler.output();
        System.out.println(outputString);
    }
}

4. 结果及分析

解释器模式优/缺与适用环境

1.解释器模式优点

（1）易于改变和扩展文法

（2）每一条文法规则都可以表示为一个类，因此可以方便的实现一个简单的语言

（3）实现文法较为容易

（4）增加新的解释表达式较为方便

2.解释器模式缺点

（1）对于复杂的文法难以维护

（2）执行效率低

3. 解释器模式的适用环境

（1）可以将一个需要解释执行的语言中的句子表达为一个抽象语法书

（2）一些重复出现的问题可以用一个简单的语言进行表达

（3）一个语言的文法比较简单

（4）执行效率不是关键问题