（Interpreter）模式：
解释器（Interpreter）模式：
解释器模式是类的行为模式。给定一个语言之后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器
来解释这个语言中的句子。
一、解释器模式所涉及的角色
1、抽象表达式角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
2、终结符表达式角色：这是一个具体角色。
（1）实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；
（2）文法中的每一个终结符都有一个具体终结表达式与之相对应。
3、非终结符表达式角色：这是一个具体角色。
（1）文法中的每一条规则 R=R1R2.....Rn 都需要一个具体的非终结符表达式类；
（2）对每一个 R1R2.....Rn 中的符号都持有一个静态类型为Expression的实例变量。
（3）实现解释操作，即 interpret()方法。解释操作以递归方式调用上面所提到的代表 R1R2.....Rn 中的各个符号的实
例变量
4、客户端角色：代表模式的客户端它有以下功能
（1）建造一个抽象语法树（AST或者Abstract Syntax Tree）
（2）调用解释操作interpret()。
5、环境角色：（在一般情况下，模式还需要一个环境角色）提供解释器之外的一些全局信息，比如变量的真实量值等。
（抽象语法树的每一个节点都代表一个语句，而在每一个节点上都可以执行解释方法。这个解释方法的执行就代表这个语句被解释。
由于每一个语句都代表对一个问题实例的解答。）
来举一个加减乘除的例子吧，实现思路来自于《java与模式》中的例子。每个角色的功能按照上面提到的规范来实现。
//上下文（环境）角色，使用HashMap来存储变量对应的数值
class Context
{
private Map valueMap = new HashMap();
public void addValue(Variable x , int y)
{
Integer yi = new Integer(y);
valueMap.put(x , yi);
}
public int LookupValue(Variable x)
{
int i = ((Integer)valueMap.get(x)).intValue();
return i ;
}
}
//抽象表达式角色，也可以用接口来实现
abstract class Expression
{
public abstract int interpret(Context con);
}
//终结符表达式角色
class Constant extends Expression
{
private int i ;
public Constant(int i)
{
this.i = i;
}
public int interpret(Context con)
{
return i ;
}
}
class Variable extends Expression
{
public int interpret(Context con)
{
//this为调用interpret方法的Variable对象
return con.LookupValue(this);
}
}
//非终结符表达式角色
class Add extends Expression
{
private Expression left ,right ;
public Add(Expression left , Expression right)
{
this.left = left ;
this.right= right ;
}
public int interpret(Context con)
{
return left.interpret(con) + right.interpret(con);
}
}
class Subtract extends Expression
{
private Expression left , right ;
public Subtract(Expression left , Expression right)
{
this.left = left ;
this.right= right ;
}
public int interpret(Context con)
{
return left.interpret(con) - right.interpret(con);
}
}
class Multiply extends Expression
{
private Expression left , right ;
public Multiply(Expression left , Expression right)
{
this.left = left ;
this.right= right ;
}
public int interpret(Context con)
{
return left.interpret(con) * right.interpret(con);
}
}
class Division extends Expression
{
private Expression left , right ;
public Division(Expression left , Expression right)
{
this.left = left ;
this.right= right ;
}
public int interpret(Context con)
{
try{
return left.interpret(con) / right.interpret(con);
}catch(ArithmeticException ae)
{
System.out.println("被除数为0！");
return -11111;
}
}
}
//测试程序，计算 (a*b)/(a-b+2)
public class Test
{
private static Expression ex ;
private static Context con ;
public static void main(String[] args)
{
con = new Context();
//设置变量、常量
Variable a = new Variable();
Variable b = new Variable();
Constant c = new Constant(2);
//为变量赋值
con.addValue(a , 5);
con.addValue(b , 7);
//运算，对句子的结构由我们自己来分析，构造
ex = new Division(new Multiply(a , b), new Add(new Subtract(a , b) , c));
System.out.println("运算结果为："+ex.interpret(con));
}
}
01.package designpattern.intpreter;
02.import java.util.HashMap;
03.
04.public interface Expression {
05. public int interprete(HashMap<String,Integer> var);
06.}
07.//////////////////////////
08.package designpattern.intpreter;
09.
10.import java.util.HashMap;
11.
12.public class VarExpression implements Expression{
13. private String key;
14. public VarExpression(String key){
15. this.key = key;
16. }
17.
18. public int interprete(HashMap<String,Integer> var) {
19. return (Integer)var.get(this.key);
20. }
21.}
22.////////////////////////////
23.package designpattern.intpreter;
24.
25.public abstract class SymbolExpression implements Expression {
26. protected Expression left;
27. protected Expression right;
28.
29. // 所有的解析公式都应只关心自己左右两个表达式的结果
30. public SymbolExpression(Expression left, Expression right) {
31. this.left = left;
32. this.right = right;
33. }
34.}
35.//////////////////////////////////
36.package designpattern.intpreter;
37.
38.import java.util.HashMap;
39.
40.public class AddExpression extends SymbolExpression {
41. public AddExpression(Expression _left, Expression _right) {
42. super(_left, _right);
43. }
44.
45. // 把左右两个表达式运算的结果加起来
46. public int interprete(HashMap<String, Integer> var) {
47. return super.left.interprete(var) + super.right.interprete(var);
48. }
49.}
50.///////////////////////////////////
51.package designpattern.intpreter;
52.
53.import java.util.HashMap;
54.
55.public class SubExpression extends SymbolExpression {
56. public SubExpression(Expression _left, Expression _right) {
57. super(_left, _right);
58. }
59.
60. // 左右两个表达式相减
61. public int interprete(HashMap<String, Integer> var) {
62. return super.left.interprete(var) - super.right.interprete(var);
63. }
64.
65.}
66.////////////////////////////
67.package designpattern.intpreter;
68.import java.util.HashMap;
69.import java.util.Stack;
70.
71.public class Calculator {
72. private Expression expression;
73. public Calculator(String expStr) {
74. // 定义一个堆栈，安排运算的先后顺序
75. Stack<Expression> stack = new Stack<Expression>();
76. // 表达式拆分为字符数组
77. char[] charArray = expStr.toCharArray();
78. // 运算
79. Expression left = null;
80. Expression right = null;
81. for (int i = 0; i < charArray.length; i++) {
82. switch (charArray[i]) {
83. case '+': // 加法
84. // 加法结果放到堆栈中
85. left = stack.pop();
86. right = new VarExpression(String.valueOf(charArray[++i]));
87. stack.push(new AddExpression(left, right));
88. break;
89. case '-':
90. left = stack.pop();
91. right = new VarExpression(String.valueOf(charArray[++i]));
92. stack.push(new SubExpression(left, right));
93. break;
94. default: // 公式中的变量
95. stack.push(new VarExpression(String.valueOf(charArray[i])));
96. }
97. }
98. // 把运算结果抛出来
99. this.expression = stack.pop();
100. }
101.
102. // 开始运算
103. public int run(HashMap<String, Integer> var) {
104. return this.expression.interprete(var);
105. }
106.}
107.//////////////////////////////
108.//测试用例
109.package designpattern.intpreter;
110.import java.util.HashMap;
111.
112.public class Client {
113. public static void main(String[] args){
114. //构造运算元素的值列表
115. HashMap<String, Integer> ctx = new HashMap<String, Integer>();
116. ctx.put("a", 10);
117. ctx.put("b", 20);
118. ctx.put("c", 30);
119. ctx.put("d", 40);
120. ctx.put("e", 50);
121. ctx.put("f", 60);
122. Calculator calc = new Calculator("a+b-c");
123. int result = calc.run(ctx);
124. System.out.println("Result of a+b-c: " + result);
125. calc = new Calculator("d-a-b+c");
126. result = calc.run(ctx);
127. System.out.println("Result of d-a-b+c: " + result);
128. }
129.}
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sunxing007/archive/2010/04/12/5477634.aspx
