相关文章
 【合集】Java设计模式
    
    
 
总结
 思维:逐个节点的进行读取解析运算
角色
 抽象表达式
终结符表达式
非终结符表达式
环境角色
客户端
优缺点
 优点:易于扩展、实现文法较为容易
缺点:对于复杂文法难以维护、执行效率较低
使用场景
 当语言的文法较为简单,且执行效率不是关键问题时。
当问题重复出现,且可以用一种简单的语言来进行表达时。
当一个语言需要解释执行,并且语言中的句子可以表示为一个抽象语法树的时候。
解释器模式
 环境角色类
 
 1
  2
  3
  4
  5
  6
  7
  8
  9
 10
  
public   static   class  Context   { 
      // 变量 值 map 
      private   final   Map < Variable ,   Integer >   map   =   new   HashMap <> (); 
      public   void   assign ( Variable   var ,   Integer   value )   { 
          map . put ( var ,   value ); 
      } 
      public   int   getValue ( Variable   var )   { 
          return   map . get ( var ); 
      } 
 } 
  
 
抽象表达式
 
1
 2
 3
  
public   static   abstract   class  AbstractExpression   { 
      public   abstract   int   interpret ( Context   context ); 
 } 
  
 
终结符表达式:变量表达式
 
 1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
  
@AllArgsConstructor 
 public   static   class  Variable   extends   AbstractExpression   { 
      private   String   name ; 
      public   int   interpret ( Context   context )   { 
          return   context . getValue ( this ); 
      } 
      @Override 
      public   String   toString ()   { 
          return   name ; 
      } 
 } 
  
 
非终结表达式:加法表达式
 
 1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
  
@AllArgsConstructor 
 public   static   class  Plus   extends   AbstractExpression   { 
      // +号左边的表达式 
      private   AbstractExpression   left ; 
      // +号右边的表达式 
      private   AbstractExpression   right ; 
      @Override 
      public   int   interpret ( Context   context )   { 
          // 将左边表达式的结果和右边表达式的结果进行相加 
          return   left . interpret ( context )   +   right . interpret ( context ); 
      } 
      @Override 
      public   String   toString ()   { 
          return   "("   +   left . toString ()   +   " + "   +   right . toString ()   +   ")" ; 
      } 
 } 
  
 
非终结表达式:减法表达式
 
 1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
  
@AllArgsConstructor 
 public   static   class  Minus   extends   AbstractExpression   { 
      // -号左边的表达式 
      private   AbstractExpression   left ; 
      // -号右边的表达式 
      private   AbstractExpression   right ; 
      @Override 
      public   int   interpret ( Context   context )   { 
          // 将左边表达式的结果和右边表达式的结果进行相减 
          return   left . interpret ( context )   -   right . interpret ( context ); 
      } 
      @Override 
      public   String   toString ()   { 
          return   "("   +   left . toString ()   +   " - "   +   right . toString ()   +   ")" ; 
      } 
 } 
  
 
客户端调用
 
 1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
  
Context   context   =   new   Context (); 
 Variable   a   =   new   Variable ( "a" ); 
 Variable   b   =   new   Variable ( "b" ); 
 Variable   c   =   new   Variable ( "c" ); 
 Variable   d   =   new   Variable ( "d" ); 
 
 context . assign ( a ,   1 ); 
 context . assign ( b ,   2 ); 
 context . assign ( c ,   3 ); 
 context . assign ( d ,   4 ); 
 
 // 获取抽象语法树 a + b - c + d 
 AbstractExpression   expression   =   new   Plus ( a ,   new   Minus ( new   Minus ( b ,   c ),   d )); 
 
 //  解释(计算) 
 int   result   =   expression . interpret ( context ); 
 System . out . println ( expression   +   " = "   +   result ); 
  
 
输出
 
1
  
( a + (( b - c)  - d))  =  -4
 
 
 
    
    
    
    
    
        
   
        Licensed under CC BY-NC-SA 4.0