自定义语言的实现——解释器模式（五）

18.5 再谈Context的作用

在解释器模式中，环境类Context用于存储解释器之外的一些全局信息，它通常作为参数被传递到所有表达式的解释方法interpret()中，可以在Context对象中存储和访问表达式解释器的状态，向表达式解释器提供一些全局的、公共的数据，此外还可以在Context中增加一些所有表达式解释器都共有的功能，减轻解释器的职责。

在上面的机器人控制程序实例中，我们省略了环境类角色，下面再通过一个简单实例来说明环境类的用途：

Sunny软件公司开发人员通过分析，根据该格式化指令中句子的组成，定义了如下文法规则：

expression ::= command* //表达式，一个表达式包含多条命令

command ::= loop | primitive //语句命令

loop ::= 'loop number' expression 'end' //循环命令，其中number为自然数

primitive ::= 'print string' | 'space' | 'break' //基本命令，其中string为字符串

根据以上文法规则，通过进一步分析，绘制如图18-6所示结构图：

图18-6 格式化指令结构图

在图18-6中，Context充当环境角色，Node充当抽象表达式角色，ExpressionNode、CommandNode和LoopCommandNode充当非终结符表达式角色，PrimitiveCommandNode充当终结符表达式角色。完整代码如下所示：

    import java.util.*;
    
    //环境类：用于存储和操作需要解释的语句，在本实例中每一个需要解释的单词可以称为一个动作标记(Action Token)或命令
    class Context {
    	private StringTokenizer tokenizer; //StringTokenizer类，用于将字符串分解为更小的字符串标记(Token)，默认情况下以空格作为分隔符
    	private String currentToken; //当前字符串标记
    	
    	public Context(String text) {
    		tokenizer = new StringTokenizer(text); //通过传入的指令字符串创建StringTokenizer对象
    		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.err.println("错误提示：" + currentToken + "解释错误！");
    			}
    		nextToken();
    	}
    	
    	//如果当前的标记是一个数字，则返回对应的数值
    	public int currentNumber() {
    		int number = 0;
    		try{
    			number = Integer.parseInt(currentToken); //将字符串转换为整数
    		}
    		catch(NumberFormatException e) {
    			System.err.println("错误提示：" + e);
    		}
    		return number;
    	}
    }
    
    //抽象节点类：抽象表达式
    abstract class Node {
    	public abstract void interpret(Context text); //声明一个方法用于解释语句
    	public abstract void execute(); //声明一个方法用于执行标记对应的命令
    }
    
    //表达式节点类：非终结符表达式
    class ExpressionNode extends Node {
    	private ArrayList<Node> list = new ArrayList<Node>(); //定义一个集合用于存储多条命令
    	
    	public void interpret(Context context) {
            //循环处理Context中的标记
    		while (true){
                //如果已经没有任何标记，则退出解释
    			if (context.currentToken() == null) {
    				break;
    			}
                //如果标记为END，则不解释END并结束本次解释过程，可以继续之后的解释
    			else if (context.currentToken().equals("END")) {
    				context.skipToken("END");
    				break;
    			}
                //如果为其他标记，则解释标记并将其加入命令集合
    			else {
    				Node commandNode = new CommandNode();
    				commandNode.interpret(context);
    				list.add(commandNode);
    			}
    		}
    	}
    	
        //循环执行命令集合中的每一条命令
    	public void execute() {
    		Iterator iterator = list.iterator();
    		while (iterator.hasNext()){
    			((Node)iterator.next()).execute();
    		}
    	}
    }
    
    //语句命令节点类：非终结符表达式
    class CommandNode extends Node {
    	private Node node;
    	
    	public void interpret(Context context) {
            //处理LOOP循环命令
    		if (context.currentToken().equals("LOOP")) {
    			node = new LoopCommandNode();
    			node.interpret(context);
    		}
            //处理其他基本命令
    		else {
    			node = new PrimitiveCommandNode();
    			node.interpret(context);
    		}
    	}
    	
    	public void execute() {
    		node.execute();
    	}
    }
    
    //循环命令节点类：非终结符表达式
    class LoopCommandNode extends Node {
    	private int number; //循环次数
    	private Node commandNode; //循环语句中的表达式
    	
        //解释循环命令
    	public void interpret(Context context) {
    		context.skipToken("LOOP");
    		number = context.currentNumber();
    		context.nextToken();
    		commandNode = new ExpressionNode(); //循环语句中的表达式
    		commandNode.interpret(context);
    	}
    	
    	public void execute() {
    		for (int i=0;i<number;i++)
    			commandNode.execute();
    	}
    }
    
    //基本命令节点类：终结符表达式
    class PrimitiveCommandNode extends Node {
    	private String name;
    	private String text;
    	
        //解释基本命令
    	public void interpret(Context context) {
    		name = context.currentToken();
    		context.skipToken(name);
    	    if (!name.equals("PRINT") && !name.equals("BREAK") && !name.equals ("SPACE")){
    			System.err.println("非法命令！");
    		}
    		if (name.equals("PRINT")){
    			text = context.currentToken();
    			context.nextToken();
    		}
    	}
    	
    	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();
    	}
    }

在本实例代码中，环境类Context类似一个工具类，它提供了用于处理指令的方法，如nextToken()、currentToken()、skipToken()等，同时它存储了需要解释的指令并记录了每一次解释的当前标记(Token)，而具体的解释过程交给表达式解释器类来处理。我们还可以将各种解释器类包含的公共方法移至环境类中，更好地实现这些方法的重用和扩展。

针对本实例代码，我们编写如下客户端测试代码：

    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();
    	}
    }

编译并运行程序，输出结果如下：

杨过小龙女

杨过小龙女

郭靖黄蓉

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

• 大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
• 原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
• 持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
• 覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
• 不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
• 宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
• 宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
• 宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】 即可免费领取。