设计模式之：解释器模式(Interpreter)

Interpreter模式，即解释器模式。
　　解释器模式属于行为模式，Gof是这样定义的：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解
    释语言中的句子。
　　解释器模式需要解决的是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子]
。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

　　实例应用：正则表达式

举例说明：

[java]  view plain  copy

 print ?

1. package design.interpreter;  
2.   
3. /** 
4.  * 文件名称：Context.java 
5.  * 创建人：Fei Wong 
6.  * 创建时间： Jun 25, 2012 
7.  * 电子邮箱：feiwong8@126.com 
8.  *  解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等 
9.  * */  
10.   
11. public class Context {  
12.     private String in ;  
13.       
14.     private int out ;  
15.       
16.     public Context(String in) {  
17.         this.in = in ;   
18.     }  
19.   
20.     public int getOut() {  
21.         return out;  
22.     }  
23.   
24.     public void setOut(int out) {  
25.         this.in = String.valueOf( out ) ;    
26.         this.out = out;  
27.     }  
28.   
29.     public String getIn() {  
30.         return in;  
31.     }  
32.       
33.       
34. }  
35.   
36.   
37.   
38.   
39. package design.interpreter;  
40.   
41. /** 
42.  * 文件名称：AbstractExpression.java 
43.  * 创建人：Fei Wong 
44.  * 创建时间： Jun 25, 2012 
45.  * 电子邮箱：feiwong8@126.com 
46.  *  解释器抽象类。 
47.  * */  
48.   
49. public abstract class AbstractExpression {  
50.     public abstract void interpret(Context context);   
51. }  
52.   
53.   
54.   
55.   
56. package design.interpreter;  
57.   
58. /** 
59.  * 文件名称：MinusExpression.java 创建人：Fei Wong 创建时间： Jun 25, 2012 
60.  * 电子邮箱：feiwong8@126.com 
61.  *   解释器具体实现类。 
62.  */  
63.   
64. public class MinusExpression extends AbstractExpression {  
65.   
66.     @Override  
67.     public void interpret(Context context) {  
68.         String in = context.getIn();  
69.         int v = Integer.parseInt(in);  
70.         context.setOut(--v);  
71.     }  
72.   
73. }  
74.   
75.   
76.   
77.   
78. package design.interpreter;  
79.   
80. /** 
81.  * 文件名称：PlusExpression.java 
82.  * 创建人：Fei Wong 
83.  * 创建时间： Jun 25, 2012 
84.  * 电子邮箱：feiwong8@126.com 
85.  *   解释器具体实现类。  
86.  * */  
87.   
88. public class PlusExpression extends AbstractExpression {  
89.       
90.     @Override  
91.     public void interpret(Context context) {  
92.         String in = context.getIn() ;   
93.         int v = Integer.parseInt( in ) ;  
94.         context.setOut( ++v ) ;   
95.     }  
96.   
97. }  
98.   
99.   
100.   
101.   
102. package design.interpreter;  
103.   
104. /** 
105.  * 文件名称：Client.java 
106.  * 创建人：Fei Wong 
107.  * 创建时间： Jun 25, 2012 
108.  * 电子邮箱：feiwong8@126.com 
109.  * */  
110.   
111. public class Client {  
112.   
113.     /** 
114.      * @param args 
115.      */  
116.     public static void main(String[] args) {  
117.         Context context = new Context( "10" ) ;  
118.           
119.         new MinusExpression().interpret(context) ;   
120.         new PlusExpression().interpret(context) ;   
121.         new MinusExpression().interpret(context) ;   
122.         new PlusExpression().interpret(context) ;     
123.         System.out.println( context.getOut() );   
124.     }  
125.   
126. }