一.什么是解释器模式
给定一个语言,定义文法表示,并定义一个解释器去解释定义的句子。
二.解释器模式的写法
解释器模式,主要有抽象的解释器,终结表达式,非终结表达式和上下文。如果按输入字符串得到结果的计算器来理解,抽象的解释器定义任务也就是得到的结果,终结表达式表达的是字符对应的数字的解释操作,一般只有一个,而非终结的表达式有点像各种各样的符号计算顺便返回结果。上下文环境则是定义包含解释操作的其他环境。
这次我们看看代码,我们先定义一个抽象的解释器,持有上下文引用。
public abstract class AbstractExpression {
protected abstract double interprete(Context context);
}
再来定义一组非终结表达式
/**
* 非终结表达式
* @author Seven
*
*/
public abstract class NonTerminalExpression extends AbstractExpression{
protected AbstractExpression expression1,expression2;
public NonTerminalExpression(AbstractExpression expression1, AbstractExpression expression2) {
super();
this.expression1 = expression1;
this.expression2 = expression2;
}
}
/**
* 加法表达式
* @author Seven
*
*/
public class PlusExpression extends NonTerminalExpression{
public PlusExpression(AbstractExpression expression1, AbstractExpression expression2) {
super(expression1, expression2);
}
@Override
protected double interprete(Context context) {
return expression1.interprete(context)+expression2.interprete(context);
}
}
/**
* 减法表达式
* @author Seven
*
*/
public class MinusExpression extends NonTerminalExpression{
public MinusExpression(AbstractExpression expression1, AbstractExpression expression2) {
super(expression1, expression2);
}
@Override
protected double interprete(Context context) {
return expression1.interprete(context)-expression2.interprete(context);
}
}
我们再来定义一个终结表达式
/** 终结表达式
* @author Seven
*
*/
public class TerminalExpression extends AbstractExpression{
String var;
public TerminalExpression(String var) {
super();
this.var = var;
}
@Override
protected double interprete(Context context) {
return context.lookup(this);
}
}
我们再来看看客户端测试
public class Client {
public static void main(String[] args) {
Context context = new Context();
TerminalExpression a = new TerminalExpression("a");
TerminalExpression b = new TerminalExpression("b");
TerminalExpression c = new TerminalExpression("c");
context.add(a, 4.0);
context.add(b, 8.0);
context.add(c, 2.0);
// 以上定义将终结表达式所表示的内容一一对应起来,并放到上下文环境中。可以理解为也就是定义文法,解释器的规则。
AbstractExpression abstractExpression = new MinusExpression(b, c);
System.out.println(abstractExpression.interprete(context)); //得到结果6
AbstractExpression abstractExpression1 = new PlusExpression(b, c);
System.out.println(abstractExpression1.interprete(context));//得到结果10
AbstractExpression abstractExpression2 = new PlusExpression(abstractExpression, c);
System.out.println(abstractExpression2.interprete(context));//先执行abstractExpression的interprete得到结果6,在减去c的interpreter得到的值 然后得到结果8
// System.out.println(new MinusExpression(new PlusExpression(a,b), c).interprete(context));
}
}
三.小结
以上就是一个解释器模式的代码写法,解释器模式是为了解决一些文法的表达和转换,采用的是一种递归调用,所以看上去不是很好理解,看下最后一个的测试代码。当我们有一些简单的文法表达式可使用解释器模式。