原文地址
http://blog.csdn.net/qq_25806863/article/details/68944729
解释器模式是一种行为模式,实际开发中用的很少,提供了一种解释语言的语法或表达式的方式。
定义了一个表达式接口,通过接口解释一个特定的上下文。类似于json解析器按一定的语法解析json的。
定义
给定一个语言,定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子。
什么是文法?文法就是语言的规则,语法。每一个语法都对应一个解释器对象,解释器根据语法来解释相应的句子。
举个例子,那汉语中的主谓宾结构来说,我们经常是自己是什么是这样说的,我是程序员
,`我是设计师
…。那么,就可以把我是[职位]
定义为一条文法。解释器一看见这样的文法,就能解析出来你的职业是[职业]
。
使用场景
- 当一个语言需要解释执行,并且该语言中的句子可以表示为一个抽象的语法树时。
- 某些重复出现的问题,可以用一种简单的语言来表示的时候,可以将这个问题转化为一种语法规则下的语句。
UML
- AbstractExpression:抽象的解析方法。声明一个解析方法,具体实现在具体的子类中完成
- TernimalExprission:实现对文法中与终结符有关的解释操作。
- NonterminalExpression:实现对文法中的非终结符有关的解释操作。
- Context:包含解释器之外的全部信息。
- Client: 解析表达式,构建抽象语法书,执行具体的解释操作等。
简单实现
以数字计算为例,`a+b+c
,如果使用解释器模式对表达式进行解释,那么a,b,c可以看做是终结负号,+
看做是非终结负号。
抽象的解释器,定义每个解释器都有个方法提取结果值
public abstract class ArithmeticExpression {
public abstract int interpret();
}
数字解释器,仅仅解释数字
public class NumExpression extends ArithmeticExpression {
private int num;
public NumExpression(int num) {
this.num = num;
}
@Override
public int interpret() {
return num;
}
}
抽象的运算符解释器,要求传入两个参数进行计算
public abstract class OperatorExpression extends ArithmeticExpression {
protected ArithmeticExpression exp1,exp2;
public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
this.exp1 = exp1;
this.exp2 = exp2;
}
}
一个具体的加法运算符,解析出两个参数的和
public class AddExpression extends OperatorExpression {
public AddExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
super(exp1, exp2);
}
@Override
public int interpret() {
return exp1.interpret()+exp2.interpret();
}
}
一个计算类,处理与解析相关的业务
public class Calculator {
private Stack<ArithmeticExpression> mExp = new Stack<>();
//使用的时候在构造方法里传入要计算的字符串。
public Calculator(String expression) {
//准备两个解释器
ArithmeticExpression exp1, exp2;
//将字符串按空格分割
String[] elements = expression.split(" ");
for (int i = 0; i < elements.length; i++) {
switch (elements[i].charAt(0)) {
case '+':
//如果是’+‘,说明是个运算符,将上一个数和下一个数相加,也就是当前下标i的i-1和i+1相加。
//去除栈中前一次压如的数。也就是这个加号之前的计算结果。
exp1 = mExp.pop();
//取出这个加号后面的数,解析成数字,
exp2 = new NumExpression(Integer.valueOf(elements[++i]));
//将这两个数进行计算,并将结果压入栈中。
mExp.push(new AddExpression(exp1,exp2));
break;
default:
//如果是数字,就解析为数字,加入栈中。
mExp.push(new NumExpression(Integer.valueOf(elements[i])));
break;
}
}
}
public int calculate(){
return mExp.pop().interpret();
}
}
客户端调用
public class Client {
public static void main(String[] args) {
Calculator calculator = new Calculator("1 + 2 + 3");
System.out.println(calculator.calculate());
}
}
可以看到输出结果是
6
如果需要加上减号运算符呢?就子啊实现一个减号的解析器:
public class Subtraction extends OperatorExpression {
public Subtraction(ArithmeticExpression exp1, ArithmeticExpression exp2) {
super(exp1, exp2);
}
@Override
public int interpret() {
return exp1.interpret()-exp2.interpret();
}
}
然后在计算的类里加一种判断:
case '-':
exp1 = mExp.pop();
exp2 = new NumExpression(Integer.valueOf(elements[++i]));
mExp.push(new SubtractionExpression(exp1,exp2));
break;
客户端调用
public class Client {
public static void main(String[] args) {
Calculator calculator = new Calculator("1 + 2 + 3 - 1");
System.out.println(calculator.calculate());
}
}
可以看到输出结果变成了
5
上面只是一个简单的算术运算的解析。根据这个模式,可以增加很多运算法则,只要创建响应的解释器就可以。
由于解释器和文法是一一对应的,所以一个解释器只负责解析一种文法。我们可以为一种文法创建多个解释器,但不能用一个解释器解析多重文法。
解释器值负责解析单个的文法,所以解析树的建立就有距离的使用者去根据实际情况构建了。
总结
优点
- 拓展性很灵活,需要增加新的解释器的时候,直接实现一个新的就行了,然后在实际运用中灵活构建语法树来运用。
缺点
- 每一个文法都至少对应一个解释器,会产生大量的类,维护困难。
- 对于复杂的文法,要构建语法书会非常繁琐,甚至需要构建多颗语法树。