10/11

软件设计 石家庄铁道大学信息学院

实验17：解释器模式（选作）
本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：
1、理解解释器模式的动机，掌握该模式的结构；
2、能够利用解释器模式解决实际问题。

[实验任务一]：解释器模式
某机器人控制程序包含一些简单的英文指令，其文法规则如下：
expression ::= direction action distance | composite
composite ::= expression and expression
direction ::= ‘up’ | ‘down’ | ‘left’ | ‘right’
action ::= ‘move’ | ‘run’
distance ::= an integer //一个整数值
如输入：up move 5，则输出“向上移动5个单位”；输入：down run 10 and left move 20，则输出“向下移动10个单位再向左移动20个单位”。
实验要求：
1. 提交类图；

2. 提交源代码；
3. import java.util.List;
4. import java.util.ArrayList;
5.
6. // 上下文
7. class Context {
8. private List<String> tokens;
9. private int index;
10.
11. public Context(List<String> tokens) {
12. this.tokens = tokens;
13. this.index = 0;
14. }
15.
16. public String peek() {
17. return tokens.get(index);
18. }
19.
20. public String nextToken() {
21. return tokens.get(index++);
22. }
23. }
24.
25. // 抽象表达式
26. interface AbstractExpression {
27. String interpret(Context context);
28. }
29.
30. // 方向表达式
31. class DirectionExpression implements AbstractExpression {
32. @Override
33. public String interpret(Context context) {
34. String direction = context.nextToken();
35. return direction;
36. }
37. }
38.
39. // 动作表达式
40. class ActionExpression implements AbstractExpression {
41. @Override
42. public String interpret(Context context) {
43. String action = context.nextToken();
44. return action;
45. }
46. }
47.
48. // 距离表达式
49. class DistanceExpression implements AbstractExpression {
50. @Override
51. public String interpret(Context context) {
52. String distance = context.nextToken();
53. return distance;
54. }
55. }
56.
57. // 复合表达式
58. class CompositeExpression implements AbstractExpression {
59. private AbstractExpression expr1;
60. private AbstractExpression expr2;
61.
62. public CompositeExpression(AbstractExpression expr1, AbstractExpression expr2) {
63. this.expr1 = expr1;
64. this.expr2 = expr2;
65. }
66.
67. @Override
68. public String interpret(Context context) {
69. String result = expr1.interpret(context) + "再" + expr2.interpret(context);
70. return result;
71. }
72. }
73.
74. // 表达式
75. class Expression implements AbstractExpression {
76. @Override
77. public String interpret(Context context) {
78. if ("up".equals(context.peek()) || "down".equals(context.peek()) ||
79. "left".equals(context.peek()) || "right".equals(context.peek())) {
80. return "direction action distance" + interpretDirectionActionDistance(context);
81. } else {
82. return "composite" + interpretComposite(context);
83. }
84. }
85.
86. private String interpretComposite(Context context) {
87. return new CompositeExpression(new Expression(), new Expression()).interpret(context);
88. }
89.
90. private String interpretDirectionActionDistance(Context context) {
91. AbstractExpression direction = new DirectionExpression();
92. AbstractExpression action = new ActionExpression();
93. AbstractExpression distance = new DistanceExpression();
94.
95. String result = direction.interpret(context) + " " + action.interpret(context) + " " + distance.interpret(context);
96. return result;
97. }
98. }
99.
100. // 客户端代码
101. public class InterpreterPatternDemo {
102. public static void main(String[] args) {
103. List<String> tokens = new ArrayList<>();
104. tokens.add("down");
105. tokens.add("run");
106. tokens.add("10");
107. tokens.add("and");
108. tokens.add("left");
109. tokens.add("move");
110. tokens.add("20");
111.
112. Context context = new Context(tokens);
113. AbstractExpression expression = new Expression();
114. String result = expression.interpret(context);
115. System.out.println(result);
116. }
117. }
3. 注意编程规范。