解释器模式

1 定义

解释器模式:定义一个语言的文法,并且建立一个解释器来解释该语言中的句子,这里的"语言"是指适用规定格式和语法的代码.解释器模式是一种类行为型模式.

2 解释器模式结构图

AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。
NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。
Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。

3 代码实现

abstract class AbstractExpression{
	public abstract void interpret(Context ctx);
}

class TerminalExpression extends AbstractExpression{
	public void interpret(Context ctx){
		//终结符表达式的解释操作
	}
}

class NonterminalExpression extends AbstractExpression{
	private AbstractExpression left;
	private AbstractExpression rigth;

	public NonterminalExpression(AbstractExpression left,AbstractExpression right){
		this.left = left;
		this.right = right;
	}
	
	public void interpret(Context ctx){
		//递归调用每一个组成部分的interpret()方法
		//在诋毁调用时指定组成部分的连接方式,即非终结符的功能
	}
}

class Context{
	private HashMap map = new HashMap();
	public void assign(String key,String value){
		//往环境类中设置
	}
	public String lookup(String key){
		//获取存储在环境类中的值
	}
}

4 具体实例

开发一套简单的基于字符界面的格式化指令,可以根据输入的指令在字符界面中输出一些格式化内容 ,例如输入"LOOP 2 PRINT 杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT 郭靖 SPACE SPACE PRINT 黄蓉".将输出如下结果:

代码如下:

public abstract class Node {
    public abstract void interpret(Context context);//声明一个方法用于解释
    public abstract void execute();//声明一个方法用于执行标记对应的命令
}

public class Context {

    private StringTokenizer tokenizer;
    private String currentToken; //当前字符串标记

    public Context(String text){
        tokenizer = new StringTokenizer(text);
        nextToken();
    }

    public String nextToken(){
        if(tokenizer.hasMoreTokens()){
            currentToken = tokenizer.nextToken();
        }else {
            currentToken = null;
        }
        return currentToken;
    }

    // 返回当前的标记
    public String currentToken(){
        return currentToken;
    }


    public void skipToken(String token){
        if(!token.equals(currentToken)){
            System.out.println("错误提示:" + currentToken + "解释错误!");
        }
        nextToken();
    }

    // 如果当前的标记是一个数字,则返回对应的数值
    public int currentNumber(){
        int number = 0;
        try{
            number = Integer.parseInt(currentToken);//将字符串转换成整数
        }catch (NumberFormatException e){
            System.out.println("错误提示:"+e);
        }
        return number;
    }
}

public class ExpressionNode extends Node {

    private ArrayList<Node> list = new ArrayList<Node>();

    @Override
    public void interpret(Context context) {
        //循环处理context中的标记
        int i=0;
        while(true){
            i++;
            if(context.currentToken() == null){
                //如果没有任何标记,则退出解释
                break;
            }else if(context.currentToken().equals("END")){
                //如果标记为end,不解释END并结束本次解释过程,可以继续之后的解释
                context.skipToken("END");
                break;
            }else{
                //如果为其他标记,则解释标记并将其加入命令集合
                Node commandNode = new CommandNode();
                commandNode.interpret(context);
                list.add(commandNode);
            }
        }
    }

    @Override
    public void execute() {
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Node node = (Node) iterator.next();
            node.execute();
        }
    }

}

public class CommandNode extends Node {

    private String nodeName = "CommandNode";


    private Node node;

    @Override
    public void interpret(Context context) {
        if(context.currentToken().equals("LOOP")){
            //处理循环命令
            node = new LoopCommandNode();
            node.interpret(context);
        }else{
            //处理其他基本命令
            node = new PrimitiveCommandNode();
            node.interpret(context);
        }
    }

    @Override
    public void execute() {
        node.execute();
    }

}

public class LoopCommandNode extends Node{

    private int number;//循环次数
    private Node commandNode;//循环语句中的表达式

    //解释循环命令
    @Override
    public void interpret(Context context) {
        context.skipToken("LOOP");
        number = context.currentNumber();
        context.nextToken();
        commandNode = new ExpressionNode();//循环语句中的表达式
        commandNode.interpret(context);
    }

    @Override
    public void execute() {
        for (int i = 0; i < number; i++) {
            commandNode.execute();
        }
    }

}

public class PrimitiveCommandNode extends Node {

    private String name;
    private String text;

    //解释基本命令
    @Override
    public void interpret(Context context) {
        name = context.currentToken();
        context.skipToken(name);
        if(!name.equals("PRINT") && !name.equals("BREAK") && !name.equals("END") && !name.equals("LOOP") && !name.equals("SPACE")){
            System.out.println("非法命令:" + name);
        }
        if(name.equals("PRINT")){
            text = context.currentToken();
            context.nextToken();
        }
    }

    @Override
    public void execute() {
        if(name.equals("PRINT")){
            System.out.print(text);
        }else if(name.equals("SPACE")){
            System.out.print(" ");
        }else if(name.equals("BREAK")){
            System.out.println();
        }
    }

}

public class Client {

    public static void main(String[] args) {
        String text = "LOOP 2 PRINT 杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT 郭靖 SPACE SPACE PRINT 黄蓉";
        Context context = new Context(text);
        Node node = new ExpressionNode();
        node.interpret(context);
        node.execute();
    }
}

5 优缺点及适用场景

主要优点:
1)易于改变和扩展文法.由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
2)每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
3)实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。
4)增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

主要缺点:
1)对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。
2)执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

适用场景:
1)可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
2)一些重复出现的问题可以用一种简单的语言来进行表达。
3)一个语言的文法较为简单。
4)执行效率不是关键问题。【注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。】