设计模式--解释器模式Interpreter（行为型）

1 定义：

1.1 定义：Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.(给定一门语言，定义它的方法的一种表示，并定义一个解释器，该解释器使用表示来解释语言中的句子。)

1.2 通用类图：



角色说明：

AbstractExpression——抽象解释器

具体的解释任务由各个子类完成，然而首先通过它，来向下递归解析。

TerminalExpression——终结符表达式

实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式（类），但有多个实例，对应不同的终结符。

NonterminalExpression——非终结符表达式

文法中的每条规则对应于一个非终结符表达式（类）（例如：加减法规则分别对应到AddExpression, SubExpression两个类）。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

Context——环境角色

解释器之外的一些全局信息（多为：终结符与值的映射表）。

Client——客户角色

构建表示该方法定义的语言中的一个特定的句子的抽象语法树，并调用解释操作

运行流程：将一个待解析的输入语句构建成一个抽象语法树（该语法树此时由解释器中定义的表达式构成），然后将该语法树（表达式）交给表达式对象去解释（当然是递归的）。

1.3 通用代码：

public abstract class Expression {
// 每个表达式必须有一个解析任务
public abstract Object interpreter(Context ctx);
}

public class TerminalExpression extends Expression {
// 通常终结符表达式只有一个，但是有多个对象
public Object interpreter(Context ctx) {
return null;
}
}

public class NonterminalExpression extends Expression {
// 每个非终结符表达式都会对其他表达式产生依赖
public NonterminalExpression(Expression... expression) {
}

public Object interpreter(Context ctx) {
// 进行文法处理
return null;
}
}

public class Context {
}

public class Client {
public static void main(String[] args) {
Context ctx = new Context();
// 通常定一个语法容器，容纳一个具体的表达式，通常为ListArray,LinkedList,Stack等类型
Stack<Expression> stack = null;
/*
* for(;;){ //进行语法判断，并产生递归调用 }
*/
// 产生一个完整的语法树，由各各个具体的语法分析进行解析
Expression exp = stack.pop();
// 具体元素进入场景
exp.interpreter(ctx);
}
}

2 优点

解释器是一个简单语法分析工具，它最显著的特点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。

3 缺点

3.1 类膨胀：每个语法都要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来了非常多的麻烦；

3.2 不便于调试：因为采用递归调用，若要排查错误，则非常复杂；

3.3 效率问题：由于使用了大量的循环和递归，效率是一个不容忽视的问题。

4 应用场景

4.1 重复发生的问题可以使用解释器模式：如服务器日志文件的分析处理；

4.2 简单语法需要解释：不过已逐步被被专用工具所取代；

5 注意事项

尽量不要在重要的模块中使用解释器模式，否则维护是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式，弥补Java编译型语言的不足。（而且已有众多开源解释器，没必要自己写。）

6 扩展

暂无

7 范例

图1



很简单的一个类图，VarExpression用来解析运算元素，各个公式能运算元素的数量是不同的，但每个运算元素都对应一个VarExpression对象。SybmolExpression负责运算符号解析，由两个子类AddExpression（负责加法运算）和SubExpression（负责减法运算）来实现。解析的工作完成了，我们还需要把安排运行的先后顺序（加减法是不用考虑，但是乘除法呢？注意扩展性），并且还要返回结果，因此我们需要增加一个封装类来进行封装处理，由于我们只做运算，暂时还不与业务有关联，定义为Calculator类，分析到这里，思路就比较清晰了，优化后加减法类图如图27-2所示。

图2



优化后加减法类图



图27-3 完整加减法类图

源代码如下：

[java]
view plaincopyprint?

/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
* all. 抽象表达式
*/
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);
}
}

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);
}
}

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))) { // 解决重复参数的问题

System.out.print("请输入" + ch + "的值:");
String in = (new BufferedReader(new InputStreamReader(
System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}
}

转自：/article/2369023.html