【设计模式】—— 解释器模式Interpret

　　模式意图

　　自定义某种语言后，给定一种文法标准，定义解释器，进行解析。

　　做过搜索的朋友们可能更了解一些，平时我们搜索所需要的词库，通常就需要用这种方式来实现。

　　应用场景

　　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);}@Overridepublic 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()+")";}}

　　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 }

　　运行结果

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

本文转自博客园xingoo的博客，原文链接：X，如需转载请自行联系原博主。

【设计模式】—— 解释器模式Interpret相关推荐

设计模式 | 解释器模式及典型应用
微信原文:设计模式 | 解释器模式及典型应用博客原文:设计模式 | 解释器模式及典型应用本文主要介绍解释器模式,在日常开发中,解释器模式的使用频率比较低解释器模式解释器模式(Interpret ...
Python设计模式-解释器模式
Python设计模式-解释器模式代码基于3.5.2,代码如下; #coding:utf-8 #解释器模式class PlayContext():play_text = Noneclass Expre ...
解释器android,Android的设计模式-解释器模式
前言 Android的设计模式系列文章介绍,欢迎关注,持续更新中: 1.定义给定一门语言,定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子. 2.介绍解释器模式属于行 ...
C++设计模式-解释器模式
目录基本概念代码与实例基本概念解释器模式(interpreter):给定一个语言,定义他的文法的一种表示,并定义一个解释器,这个解释器应该使用该表示来解释语言中的句子. 如果一种特定类型的问题 ...
深入浅出设计模式——解释器模式（Interpreter Pattern）
模式动机如果在系统中某一特定类型的问题发生的频率很高,此时可以考虑将这些问题的实例表述为一个语言中的句子,因此可以构建一个解释器,该解释器通过解释这些句子来解决这些问题. 解释器模式描述了如何构成一 ...
PHP设计模式——解释器模式
声明:本系列博客参考资料<大话设计模式>,作者程杰. 解释器模式:Given a language, define arepresentation for its grammar alon ...
初识设计模式 - 解释器模式
简介在某些情况下,为了更好地描述某一些特定类型的问题,我们可以创建一种新的语言,这种语言拥有自己的表达式和结构,即文法规则. 解释器设计模式(Interpreter Design Pattern)描 ...
Java设计模式--解释器模式
解释器模式给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. Interpreter Pattern Given a language, define ...
设计模式——解释器模式
名称 Interpreter 结构意图给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 适用性当有 1// Interpreter 2 ...
C++设计模式——解释器模式（interpreter pattern）
一.原理讲解 1.1意图给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 1.2应用场景文法简单.对于复杂的文法,文法的类层次变得庞大而无法管理:此 ...

【设计模式】—— 解释器模式Interpret

模式意图

应用场景

模式结构

【设计模式】—— 解释器模式Interpret相关推荐

最新文章

热门文章