（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