做那种英文网站有流量/视频广告联盟平台

通俗的说:解释器就是要去解释一个句子,一个什么样的句子呢,比如a+b-c,这就是一个句子.其中a,b,c是变量,+,-是运算符号.这样解释器就需要去解释这两种元素,如下图:其中VarExpression是变量解释器,SubExpression与AddExpression是运算符号解释器.

    先看:

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 SubExpression(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.interpreter(var);
}
}

例子中Calculator封装了解释器,并清晰的说明了解释器,而且用Stack清晰的去表达了解释器模式.的运行过程及作用

下面为解释器的抽象是

public abstract class Expression {
//解析公式和数值,其中var中的key值是是公式中的参数，value值是具体的数字
public abstract int interpreter(HashMap<String,Integer> var);
}

下面为变量解释器抽象的实现

public class VarExpression extends Expression {
private String key;
public VarExpression(String _key){
this.key = _key;
}
//从map中取之
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}

下面为动作解释器实现抽象解释器的一个抽象类

public abstract class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
//所有的解析公式都应只关心自己左右两个表达式的结果
public SymbolExpression(Expression _left,Expression _right){
this.left = _left;
this.right = _right;
}
}

下面为动作解释器抽象的实现

public class AddExpression extends SymbolExpression {
public AddExpression(Expression _left,Expression _right){
super(_left,_right);
}
//把左右两个表达式运算的结果加起来
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) + super.right.interpreter(var);
}
}
public class SubExpression extends SymbolExpression {
public SubExpression(Expression _left,Expression _right){
super(_left,_right);
}
//左右两个表达式相减
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}

不知道读者清晰了没,解释器完成解释句子的功能,然后由Context,封装串联起它们的解释,从而可以完成对一条句子的解释.

总结一下:解释器模式有4个角色:

    1.AbstractExpression 抽象解释器(Expression)

    2. TerminalExpression终结符表达式(VarExpression)

    3.NonterminalExpression 非终结符表达式(AddExpression和SubExpression)

    4. Context 环境角色(HashMap)

本文出自:http://www.cnblogs.com/cbf4life/archive/2009/12/17/1626125.html,写的很详细,很不错!