# 自定义语言的实现——解释器模式（五）
18.5 再谈Context的作用
在解释器模式中，环境类Context用于存储解释器之外的一些全局信息，它通常作为参数被传递到所有表达式的解释方法interpret()中，可以在Context对象中存储和访问表达式解释器的状态，向表达式解释器提供一些全局的、公共的数据，此外还可以在Context中增加一些所有表达式解释器都共有的功能，减轻解释器的职责。
在上面的机器人控制程序实例中，我们省略了环境类角色，下面再通过一个简单实例来说明环境类的用途：
Sunny软件公司开发了一套简单的基于字符界面的格式化指令，可以根据输入的指令在字符界面中输出一些格式化内容，例如输入“LOOP 2 PRINT杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT郭靖 SPACE SPACE PRINT 黄蓉”，将输出如下结果：
```
杨过 小龙女
杨过 小龙女
郭靖 黄蓉
```
其中关键词LOOP表示“循环”，后面的数字表示循环次数；PRINT表示“打印”，后面的字符串表示打印的内容；SPACE表示“空格”；BREAK表示“换行”；END表示“循环结束”。每一个关键词对应一条命令，计算机程序将根据关键词执行相应的处理操作。
现使用解释器模式设计并实现该格式化指令的解释，对指令进行分析并调用相应的操作执行指令中每一条命令。
Sunny软件公司开发人员通过分析，根据该格式化指令中句子的组成，定义了如下文法规则：
```
expression ::= command* //表达式，一个表达式包含多条命令
command ::= loop | primitive //语句命令
loop ::= 'loopnumber' expression 'end' //循环命令，其中number为自然数
primitive ::= 'printstring' | '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();
}
}
```
编译并运行程序，输出结果如下：
```
杨过 小龙女
杨过 小龙女
郭靖 黄蓉
```
思考
> 预测指令“LOOP 2 LOOP 2 PRINT杨过 SPACE SPACE PRINT 小龙女 BREAK END PRINT 郭靖 SPACE SPACE PRINT 黄蓉 BREAK END”的输出结果。
- Introduction
- 基础知识
- 设计模式概述
- 从招式与内功谈起——设计模式概述（一）
- 从招式与内功谈起——设计模式概述（二）
- 从招式与内功谈起——设计模式概述（三）
- 面向对象设计原则
- 面向对象设计原则之单一职责原则
- 面向对象设计原则之开闭原则
- 面向对象设计原则之里氏代换原则
- 面向对象设计原则之依赖倒转原则
- 面向对象设计原则之接口隔离原则
- 面向对象设计原则之合成复用原则
- 面向对象设计原则之迪米特法则
- 六个创建型模式
- 简单工厂模式-Simple Factory Pattern
- 工厂三兄弟之简单工厂模式（一）
- 工厂三兄弟之简单工厂模式（二）
- 工厂三兄弟之简单工厂模式（三）
- 工厂三兄弟之简单工厂模式（四）
- 工厂方法模式-Factory Method Pattern
- 工厂三兄弟之工厂方法模式（一）
- 工厂三兄弟之工厂方法模式（二）
- 工厂三兄弟之工厂方法模式（三）
- 工厂三兄弟之工厂方法模式（四）
- 抽象工厂模式-Abstract Factory Pattern
- 工厂三兄弟之抽象工厂模式（一）
- 工厂三兄弟之抽象工厂模式（二）
- 工厂三兄弟之抽象工厂模式（三）
- 工厂三兄弟之抽象工厂模式（四）
- 工厂三兄弟之抽象工厂模式（五）
- 单例模式-Singleton Pattern
- 确保对象的唯一性——单例模式 （一）
- 确保对象的唯一性——单例模式 （二）
- 确保对象的唯一性——单例模式 （三）
- 确保对象的唯一性——单例模式 （四）
- 确保对象的唯一性——单例模式 （五）
- 原型模式-Prototype Pattern
- 对象的克隆——原型模式（一）
- 对象的克隆——原型模式（二）
- 对象的克隆——原型模式（三）
- 对象的克隆——原型模式（四）
- 建造者模式-Builder Pattern
- 复杂对象的组装与创建——建造者模式（一）
- 复杂对象的组装与创建——建造者模式（二）
- 复杂对象的组装与创建——建造者模式（三）
- 七个结构型模式
- 适配器模式-Adapter Pattern
- 不兼容结构的协调——适配器模式（一）
- 不兼容结构的协调——适配器模式（二）
- 不兼容结构的协调——适配器模式（三）
- 不兼容结构的协调——适配器模式（四）
- 桥接模式-Bridge Pattern
- 处理多维度变化——桥接模式（一）
- 处理多维度变化——桥接模式（二）
- 处理多维度变化——桥接模式（三）
- 处理多维度变化——桥接模式（四）
- 组合模式-Composite Pattern
- 树形结构的处理——组合模式（一）
- 树形结构的处理——组合模式（二）
- 树形结构的处理——组合模式（三）
- 树形结构的处理——组合模式（四）
- 树形结构的处理——组合模式（五）
- 装饰模式-Decorator Pattern
- 扩展系统功能——装饰模式（一）
- 扩展系统功能——装饰模式（二）
- 扩展系统功能——装饰模式（三）
- 扩展系统功能——装饰模式（四）
- 外观模式-Facade Pattern
- 深入浅出外观模式（一）
- 深入浅出外观模式（二）
- 深入浅出外观模式（三）
- 享元模式-Flyweight Pattern
- 实现对象的复用——享元模式（一）
- 实现对象的复用——享元模式（二）
- 实现对象的复用——享元模式（三）
- 实现对象的复用——享元模式（四）
- 实现对象的复用——享元模式（五）
- 代理模式-Proxy Pattern
- 设计模式之代理模式（一）
- 设计模式之代理模式（二）
- 设计模式之代理模式（三）
- 设计模式之代理模式（四）
- 十一个行为型模式
- 职责链模式-Chain of Responsibility Pattern
- 请求的链式处理——职责链模式（一）
- 请求的链式处理——职责链模式（二）
- 请求的链式处理——职责链模式（三）
- 请求的链式处理——职责链模式（四）
- 命令模式-Command Pattern
- 请求发送者与接收者解耦——命令模式（一）
- 请求发送者与接收者解耦——命令模式（二）
- 请求发送者与接收者解耦——命令模式（三）
- 请求发送者与接收者解耦——命令模式（四）
- 请求发送者与接收者解耦——命令模式（五）
- 请求发送者与接收者解耦——命令模式（六）
- 解释器模式-Interpreter Pattern
- 自定义语言的实现——解释器模式（一）
- 自定义语言的实现——解释器模式（二）
- 自定义语言的实现——解释器模式（三）
- 自定义语言的实现——解释器模式（四）
- 自定义语言的实现——解释器模式（五）
- 自定义语言的实现——解释器模式（六）
- 迭代器模式-Iterator Pattern
- 遍历聚合对象中的元素——迭代器模式（一）
- 遍历聚合对象中的元素——迭代器模式（二）
- 遍历聚合对象中的元素——迭代器模式（三）
- 遍历聚合对象中的元素——迭代器模式（四）
- 遍历聚合对象中的元素——迭代器模式（五）
- 遍历聚合对象中的元素——迭代器模式（六）
- 中介者模式-Mediator Pattern
- 协调多个对象之间的交互——中介者模式（一）
- 协调多个对象之间的交互——中介者模式（二）
- 协调多个对象之间的交互——中介者模式（三）
- 协调多个对象之间的交互——中介者模式（四）
- 协调多个对象之间的交互——中介者模式（五）
- 备忘录模式-Memento Pattern
- 撤销功能的实现——备忘录模式（一）
- 撤销功能的实现——备忘录模式（二）
- 撤销功能的实现——备忘录模式（三）
- 撤销功能的实现——备忘录模式（四）
- 撤销功能的实现——备忘录模式（五）
- 观察者模式-Observer Pattern
- 对象间的联动——观察者模式（一）
- 对象间的联动——观察者模式（二）
- 对象间的联动——观察者模式（三）
- 对象间的联动——观察者模式（四）
- 对象间的联动——观察者模式（五）
- 对象间的联动——观察者模式（六）
- 状态模式-State Pattern
- 处理对象的多种状态及其相互转换——状态模式（一）
- 处理对象的多种状态及其相互转换——状态模式（二）
- 处理对象的多种状态及其相互转换——状态模式（三）
- 处理对象的多种状态及其相互转换——状态模式（四）
- 处理对象的多种状态及其相互转换——状态模式（五）
- 处理对象的多种状态及其相互转换——状态模式（六）
- 策略模式-Strategy Pattern
- 算法的封装与切换——策略模式（一）
- 算法的封装与切换——策略模式（二）
- 算法的封装与切换——策略模式（三）
- 算法的封装与切换——策略模式（四）
- 模板方法模式-Template Method Pattern
- 模板方法模式深度解析（一）
- 模板方法模式深度解析（二）
- 模板方法模式深度解析（三）
- 访问者模式-Visitor Pattern
- 操作复杂对象结构——访问者模式（一）
- 操作复杂对象结构——访问者模式（二）
- 操作复杂对象结构——访问者模式（三）
- 操作复杂对象结构——访问者模式（四）
- 设计模式趣味学习（复习）
- 设计模式与足球（一）
- 设计模式与足球（二）
- 设计模式与足球（三）
- 设计模式与足球（四）
- 设计模式综合应用实例
- 多人联机射击游戏
- 多人联机射击游戏中的设计模式应用（一）
- 多人联机射击游戏中的设计模式应用（二）
- 数据库同步系统
- 设计模式综合实例分析之数据库同步系统（一）
- 设计模式综合实例分析之数据库同步系统（二）
- 设计模式综合实例分析之数据库同步系统（三）