设计模式之解释器模式

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

优点：

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

缺点：

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