【设计模式 java】——解释器模式（Interpreter）

一、模式简介：

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

二、解释器模式的类图

　　                             

   　　如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决问题。我们可以通过解释器模式的结构图，来看一下它的代码实现。

三、代码实现

　　

//上下文（环境）角色，使用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));  
  
       }  
  
}  

　　解释器模式并没有说明如何创建一个抽象语法树，因此它的实现可以多种多样，在上面我们是直接在Test中提供的，当然还有更好、更专业的实现方式。

总结

　　解释器模式的优点：很容易地改变和扩展方法，因为该模式使用类来表示文法规则，我们可以使用继承来改变或扩展方法。也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些都都易于直接编写。

　　解释器模式的缺点：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器生成器来处理。

　　我们还是要在合适的地方使用合适的设计模式！