解釋器模式
- 細說模闆名稱
-
- 細說解釋器模式
-
- 定義
- UML模型
-
- 基于UML的代碼
- 場景一
-
- 場景
- 代碼
- 解釋器模式應用和注意事項
細說模闆名稱
提示：
部落客：章飛 _906285288的部落格
部落格位址：http://blog.csdn.net/qq_29924041
細說解釋器模式
解釋器模式，說句實話 ，我真的不是特别想寫這個解釋器模式，因為這玩意了解起來雖然不難，但是在實際應用中還是比較難的，算是在設計模式中比較難的一類設計模式。應用場景從目前開發來看，應用并不是那麼的廣泛，是以簡單扯扯。
定義
解釋器模式：就是按照一定的文法和規則進行解析的方案。給定一門語言，定義它的文法，并定義一個解釋器對原來的文法進行解釋
其實解釋器就是翻譯機而已，但是文法和邏輯複雜啊
UML模型
從圖上看其實解釋器模式好像也沒什麼元素内容：
1：AbstractExpression抽象的解釋器，具體的解釋任務由各個子類進行實作
2：TerminalExpression終結符解釋器，每個解釋器都要有終結符号的啊，不然怎麼知道翻譯結束了呢
3：NonterminalExpression 非終結符解釋器，每個文法規則對應的非終結文法
4：Context 環境角色
基于UML的代碼
package src.com.zzf.designpattern.interpreterpattern.demo2;
/**
* 抽象解釋器，具體的解釋任務由各個實作類來完成，
* @author Administrator
*
*/
public abstract class AbstractExpression {
public abstract Object interpreter(Context ctx);
}
package src.com.zzf.designpattern.interpreterpattern.demo2;
import src.com.zzf.designpattern.interpreterpattern.demo1.Expression;
/**
* 非終結符表達式
* @author Administrator
*
*/
public class NonterminalExpression extends AbstractExpression{
public NonterminalExpression(Expression ...expressions){
}
@Override
public Object interpreter(Context ctx) {
// TODO Auto-generated method stub
return null;
}
}
package src.com.zzf.designpattern.interpreterpattern.demo2;
/**
* 終結符表達式，通常隻有一個，但是可以對應多個對象
* @author Administrator
*
*/
public class TerminalExpression extends AbstractExpression {
@Override
public Object interpreter(Context ctx) {
// TODO Auto-generated method stub
return null;
}
}
package src.com.zzf.designpattern.interpreterpattern.demo2;
import java.util.Stack;
import src.com.zzf.designpattern.interpreterpattern.demo1.Expression;
public class Context {
public static void main(String[] args) {
Context ctx = new Context();
Stack<Expression> stack = null;
for(;;){
//進行文法填充
}
Expression exp = stack.pop();
exp.interpreter(ctx)；
}
}
可以看到起其uml的代碼其實沒有任何run的意義，其實解釋器模式确實是一種思想，就是如果結合文法翻譯規則翻譯出正确的結果。
最最重要的是分析文法規則的共性與特性，然後才能解釋
場景一
場景
照搬設計模式之禅中的四則運算
代碼
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.util.HashMap;
/**
* 抽象的解釋器
* @author zhouzhangfei
*
*/
public abstract class Expression {
public abstract int interperter(HashMap<String, Integer> var);
}
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.util.HashMap;
/**
* 變量解釋器
* @author Administrator
*
*/
public class VarExpression extends Expression {
private String key;
public VarExpression(String key){
this.key = key;
}
@Override
public int interperter(HashMap<String, Integer> var) {
// TODO Auto-generated method stub
return var.get(key);
}
}
package src.com.zzf.designpattern.interpreterpattern.demo1;
/**
* 抽象的符号解釋器
* @author zhouzhangfei
*
*/
public abstract class SymbolExpression extends Expression{
protected Expression left;
protected Expression right;
//所有的解析公式都隻關心自己左右兩個表達式的結果
public SymbolExpression(Expression _left,Expression _right){
this.left = _left;
this.right = _right;
}
}
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.util.HashMap;
/**
* 加法解釋器
* @author zhouzhangfei
*
*/
public class AddExpression extends SymbolExpression{
public AddExpression(Expression _left,Expression _right){
super(_left,_right);
}
@Override
public int interperter(HashMap<String, Integer> var) {
// TODO Auto-generated method stub
return super.left.interperter(var) + super.right.interperter(var);
}
}
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.util.HashMap;
/**
* 減法解釋器
* @author zhouzhangfei
*
*/
public class DeleteExpression extends SymbolExpression{
public DeleteExpression(Expression _left, Expression _right) {
super(_left, _right);
// TODO Auto-generated constructor stub
}
@Override
public int interperter(HashMap<String, Integer> var) {
// TODO Auto-generated method stub
return super.left.interperter(var) - super.right.interperter(var);
}
}
運算器
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.util.HashMap;
import java.util.Stack;
public class Calculator {
private Expression expression;
public Calculator(String expStr){
Stack<Expression> stack = new Stack<Expression>();
char[] charArray = expStr.toCharArray();
Expression left = null;
Expression right = null;
for(int i=0;i<charArray.length;i++){
switch(charArray[i]) {
case '+':
left = stack.pop();
right=new VarExpression(String.valueOf(charArray[++i]));
stack.push(new AddExpression(left,right));
break;
case '-':
left = stack.pop();
right=new VarExpression(String.valueOf(charArray[++i])) ;
stack.push(new DeleteExpression(left,right));
break;
default: //
stack.push(new VarExpression(String.valueOf(charArray[i])));
}
}
this.expression = stack.pop();
}
public int run(HashMap<String,Integer> var){
return this.expression.interperter(var);
}
}
package src.com.zzf.designpattern.interpreterpattern.demo1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class Client {
public static void main(String[] args) throws IOException {
String expStr = getExpStr();
HashMap<String, Integer> var = getValue(expStr);
Calculator cal = new Calculator(expStr);
System.out.println("" + expStr + "=" + cal.run(var));
}
public static String getExpStr() throws IOException {
System.out.print("請輸入");
return new BufferedReader(new InputStreamReader(System.in)).readLine();
}
//
public static HashMap<String,Integer> getValue(String exprStr) throws IOException{
HashMap<String,Integer> map = new HashMap<String,Integer>();
for(char ch:exprStr.toCharArray()){
if(ch != '+' && ch != '-'){
if(!map.containsKey(String.valueOf(ch))){
String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
map.put(String.valueOf(ch),Integer.valueOf(in));
}
}
}
return map;
}
}
解釋器模式應用和注意事項
解釋器模式其實是一個簡單文法的分析工具，具有良好的擴充性，但是如果要去解析一系列複雜文法的時候，這個時候解釋器模式可能會出現類似類膨脹，再由于解釋器模式其實使用的遞歸等，是以很容易引發一些效率上的問題。是以其在實際的開發過程中是比較少用的，但是還是很有必要進行了解，畢竟在某些業務場景下還是有可能會使用到的。再加上其思想的先進性。
歡迎繼續通路，我的部落格
![.NET程式員的技能分析參考V1.0(有附件)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)