【設計模式】—— 解釋器模式Interpret

　　前言：【模式總覽】——————————by xingoo

　　模式意圖

　　自定義某種語言後，給定一種文法標準，定義解釋器，進行解析。

　　作過搜索的朋友們可能更瞭解一些，平時咱們搜索所須要的詞庫，一般就須要用這種方式來實現。

　　應用場景

　　1 有複雜的語法分析場景

　　2 須要高效的解釋，賽過快速的效率（即看中解釋的結果，而放棄效率）

　　模式結構

　　Expression 語法解釋器的抽線模型

/** * 指定抽象表達式，具體表達式必須實現的方法 * @author xingoo * */
abstract class Expression{ /** * 以上下文環境爲準，解釋指定的表達式 * @param ctx * @return */
    public abstract boolean interpret(Context ctx); /** * 檢驗兩個表達式，是否相同 */
    public abstract boolean equals(Object o); /** * 返回表達式表明的hashCode */
    public abstract int hashCode(); /** * 轉換成字符串 */
    public abstract String toString(); }

　　如下是具體的解釋器實現過程，這裏主要模仿JAVA模式中的例子

/** * 常量表達式 * @author xingoo * */
class Constant extends Expression{ private boolean value; public Constant(boolean value){ this.value = value; } public boolean interpret(Context ctx){ return value; } public boolean equals(Object o){ if(o!=null && o instanceof Constant){ return this.value == ((Constant)o).value; } return false; } public int hashCode() { return (this.toString()).hashCode(); } public String toString() { return new Boolean(value).toString(); } } /** * 變量表達式 * @author xingoo * */
class Variable extends Expression{ private String name; public Variable(String name){ this.name = name; } public boolean interpret(Context ctx) { return ctx.lookup(this); } public boolean equals(Object o) { if(o!=null && o instanceof Variable){ return this.name.equals(((Variable)o).name); } return false; } public int hashCode() { return (this.toString()).hashCode(); } public String toString() { return name; } } /** * 與 表達式 * @author xingoo * */
class And extends Expression{ private Expression left,right; public And(Expression left,Expression right){ this.left = left; this.right = right; } public boolean interpret(Context ctx) { return left.interpret(ctx) && right.interpret(ctx); } @Override public boolean equals(Object o) { if(o!=null && o instanceof And){ return this.left.equals(((And)o).left) && this.right.equals(((And)o).right); } return false; } public int hashCode() { return (this.toString()).hashCode(); } public String toString() { return "("+left.toString()+" AND "+right.toString()+")"; } } /** * 或 表達式 * @author xingoo * */
class Or extends Expression{ private Expression left,right; public Or(Expression left,Expression right){ this.left = left; this.right = right; } public boolean interpret(Context ctx) { return left.interpret(ctx) || right.interpret(ctx); } public boolean equals(Object o) { if(o!=null && o instanceof Or){ return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right); } return false; } public int hashCode() { return (this.toString()).hashCode(); } public String toString() { return "("+left.toString()+" Or "+right.toString()+")"; } } /** * 非 表達式 * @author xingoo * */
class Not extends Expression{ private Expression exp; public Not(Expression exp){ this.exp = exp; } public boolean interpret(Context ctx) { return !exp.interpret(ctx); } public boolean equals(Object o) { if(o!=null && o instanceof Not){ return this.exp.equals(((Not)o).exp); } return false; } public int hashCode() { return (this.toString()).hashCode(); } public String toString() { return "(Not "+exp.toString()+")"; } }

View Code

　　Context 上下文環境，存儲一些表達式的內容

/** * 上下文環境 * @author xingoo * */
class Context{ private HashMap map = new HashMap(); public void assign(Variable var,boolean value){ map.put(var, new Boolean(value)); } public boolean lookup(Variable var) throws IllegalArgumentException{ Boolean value = (Boolean)map.get(var); if(value == null){ throw new IllegalArgumentException(); } return value.booleanValue(); } }

　　所有代碼

 1 package com.xingoo.interpreter;  2 
 3 import java.util.HashMap;  4 /**  5  * 指定抽象表達式，具體表達式必須實現的方法  6  * @author xingoo  7  *  8  */
 9 abstract class Expression{  10     /**  11  * 以上下文環境爲準，解釋指定的表達式  12  * @param ctx  13  * @return  14      */
 15     public abstract boolean interpret(Context ctx);  16     /**  17  * 檢驗兩個表達式，是否相同  18      */
 19     public abstract boolean equals(Object o);  20     /**  21  * 返回表達式表明的hashCode  22      */
 23     public abstract int hashCode();  24     /**  25  * 轉換成字符串  26      */
 27     public abstract String toString();  28 }  29 /**  30  * 常量表達式  31  * @author xingoo  32  *  33  */
 34 class Constant extends Expression{  35     private boolean value;  36     public Constant(boolean value){  37         this.value = value;  38  }  39     public boolean interpret(Context ctx){  40         return value;  41  }  42     public boolean equals(Object o){  43         if(o!=null && o instanceof Constant){  44             return this.value == ((Constant)o).value;  45  }  46         return false;  47  }  48     public int hashCode() {  49         return (this.toString()).hashCode();  50  }  51     public String toString() {  52         return new Boolean(value).toString();  53  }  54 }  55 /**  56  * 變量表達式  57  * @author xingoo  58  *  59  */
 60 class Variable extends Expression{  61     private String name;  62     
 63     public Variable(String name){  64         this.name = name;  65  }  66     
 67     public boolean interpret(Context ctx) {  68         return ctx.lookup(this);  69  }  70     
 71     public boolean equals(Object o) {  72         if(o!=null && o instanceof Variable){  73             return this.name.equals(((Variable)o).name);  74  }  75         return false;  76  }  77 
 78     public int hashCode() {  79         return (this.toString()).hashCode();  80  }  81     public String toString() {  82         return name;  83  }  84     
 85 }  86 /**  87  * 與 表達式  88  * @author xingoo  89  *  90  */
 91 class And extends Expression{  92     private Expression left,right;  93     
 94     public And(Expression left,Expression right){  95         this.left = left;  96         this.right = right;  97  }  98     
 99     public boolean interpret(Context ctx) { 100         return left.interpret(ctx) && right.interpret(ctx); 101  } 102 
103  @Override 104     public boolean equals(Object o) { 105         if(o!=null && o instanceof And){ 106             return this.left.equals(((And)o).left) && this.right.equals(((And)o).right); 107  } 108         return false; 109  } 110 
111     public int hashCode() { 112         return (this.toString()).hashCode(); 113  } 114 
115     public String toString() { 116         return "("+left.toString()+" AND "+right.toString()+")"; 117  } 118 } 119 /** 120  * 或 表達式 121  * @author xingoo 122  * 123  */
124 class Or extends Expression{ 125     private Expression left,right; 126     
127     public Or(Expression left,Expression right){ 128         this.left = left; 129         this.right = right; 130  } 131     
132     public boolean interpret(Context ctx) { 133         return left.interpret(ctx) || right.interpret(ctx); 134  } 135 
136     public boolean equals(Object o) { 137         if(o!=null && o instanceof Or){ 138             return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right); 139  } 140         return false; 141  } 142 
143     public int hashCode() { 144         return (this.toString()).hashCode(); 145  } 146 
147     public String toString() { 148         return "("+left.toString()+" Or "+right.toString()+")"; 149  } 150 } 151 /** 152  * 非 表達式 153  * @author xingoo 154  * 155  */
156 class Not extends Expression{ 157     private Expression exp; 158     
159     public Not(Expression exp){ 160         this.exp = exp; 161  } 162     
163     public boolean interpret(Context ctx) { 164         return !exp.interpret(ctx); 165  } 166 
167     public boolean equals(Object o) { 168         if(o!=null && o instanceof Not){ 169             return this.exp.equals(((Not)o).exp); 170  } 171         return false; 172  } 173 
174     public int hashCode() { 175         return (this.toString()).hashCode(); 176  } 177 
178     public String toString() { 179         return "(Not "+exp.toString()+")"; 180  } 181     
182 } 183 /** 184  * 上下文環境 185  * @author xingoo 186  * 187  */
188 class Context{ 189     
190     private HashMap map = new HashMap(); 191     
192     public void assign(Variable var,boolean value){ 193         map.put(var, new Boolean(value)); 194  } 195     
196     public boolean lookup(Variable var) throws IllegalArgumentException{ 197         Boolean value = (Boolean)map.get(var); 198         if(value == null){ 199             throw new IllegalArgumentException(); 200  } 201         return value.booleanValue(); 202  } 203 } 204 public class Client { 205     private static Context ctx; 206     private static Expression exp; 207     public static void main(String[] args) { 208         ctx = new Context(); 209         Variable x = new Variable("x"); 210         Variable y = new Variable("y"); 211         
212         Constant c = new Constant(true); 213         
214         //放入上下文中
215         ctx.assign(x, false); 216         ctx.assign(y, true); 217         
218         exp = new Or(new And(c,x),new And(y,new Not(x))); 219         System.out.println("x = "+x.interpret(ctx)); 220         System.out.println("y = "+y.interpret(ctx)); 221         System.out.println(exp.toString() +" = "+exp.interpret(ctx)); 222  } 223 }

View Code

　　運行結果

x = false y = true ((true AND x) Or (y AND (Not x))) = true