（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