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

最新推荐文章于 2023-11-11 07:00:00 发布

benbenxiongyuan

最新推荐文章于 2023-11-11 07:00:00 发布

阅读量654

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

30 篇文章 4 订阅

订阅专栏

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 plain copy print ?

/**
* @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;
}
}

转自：http://blog.csdn.net/yuanlong_zheng/article/details/7584871

benbenxiongyuan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式--解释器模式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.(给定一门语言，定义它的方法的一种表示，并定义一个解释器，该解释器使
复制链接

扫一扫