设计模式之解释器模式

解释器模式定义：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

优点：

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

缺点：

1、解释器模式会引起类膨胀。

2、解释器模式采用递归调用方法。

3、效率问题。

类图如下：



实现代码如下：

抽象的表达式类：

package com.designpatterns.interpreter;

import java.util.HashMap;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午4:28:15
* 类说明：Alljava
*/
public abstract class AbstractExpression {
public abstract int interpreter(HashMap<String, Integer> var);
}

变量解释器类：

package com.designpatterns.interpreter;

import java.util.HashMap;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午4:31:09 类说明：Alljava
*/
public class VarExpression extends AbstractExpression {
private String key;

public VarExpression(String key) {
this.key = key;
}

@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}

抽象运算符解释器类：

package com.designpatterns.interpreter;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午4:33:55 类说明：Alljava
*/
public abstract class SymbolExpression extends AbstractExpression {
protected AbstractExpression left;
protected AbstractExpression right;

public SymbolExpression(AbstractExpression left, AbstractExpression right) {
this.left = left;
this.right = right;
}
}

加法解释器：

package com.designpatterns.interpreter;

import java.util.HashMap;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午5:05:49
* 类说明：Alljava
*/
public class AddExpression extends SymbolExpression {

public AddExpression(AbstractExpression left, AbstractExpression right) {
super(left, right);
}

@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var)+super.right.interpreter(var);
}

}

加法解释器：

package com.designpatterns.interpreter;

import java.util.HashMap;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午5:04:45
* 类说明：Alljava
*/
public class SubExpression extends SymbolExpression {

public SubExpression(AbstractExpression left, AbstractExpression right) {
super(left, right);
}

@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var)-super.right.interpreter(var);
}

}

解析器封装类：

package com.designpatterns.interpreter;

import java.util.HashMap;
import java.util.Stack;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午5:06:26 类说明：Alljava
*/
public class Calculator {
private AbstractExpression AE;

public Calculator(String expStr) {
Stack<AbstractExpression> s = new Stack<AbstractExpression>();
char[] chararray = expStr.toCharArray();
AbstractExpression left = null;
AbstractExpression right = null;
for (int i = 0; i < chararray.length; i++) {
switch (chararray[i]) {
case '+':
left = s.pop();
right = new VarExpression(String.valueOf(chararray[++i]));
s.push(new AddExpression(left, right));
break;

case '-':
left = s.pop();
right = new VarExpression(String.valueOf(chararray[++i]));
s.push(new SubExpression(left, right));
break;
default:
s.push(new VarExpression(String.valueOf(chararray[i])));
break;
}
}
this.AE = s.pop();
}

public int run(HashMap<String, Integer> var) {
return this.AE.interpreter(var);
}
}

测试类：

package com.designpatterns.interpreter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

/**
* @author WSYW126
* @version 创建时间：2016年5月8日 下午5:14:28 类说明：Alljava
*/
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));

}

private static HashMap<String, Integer> getValue(String expStr)
throws IOException {
HashMap<String, Integer> map = new HashMap<String, Integer>();
for (char ch : expStr.toCharArray()) {
if (ch != '+' && ch != '-') {
if (!map.containsKey(String.valueOf(ch))) {
String in = (new BufferedReader(new InputStreamReader(
System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}

private static String getExpStr() throws IOException {
System.out.println("请输入计算的表达式：");
return (new BufferedReader(new InputStreamReader(System.in)))
.readLine();
}

}

这就是解释器模式。

参考资料：
设计模式之禅

备注：

转载请注明出处：http://blog.csdn.net/wsyw126/article/details/51336078

作者：WSYW126