"围观"设计模式(27)--行为型之解释器模式（Interpreter Pattern）

解析器是一种按照规定的语法进行解析的例子，在现在的项目中使用较少，定义如下：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器用于解释语言中的句子。

个人理解

解释器模式在项目中很少使用，因为他会引起效率、性能以及维护等问题，准备使用该模式时可以考虑开源框架如：Expression4J、MESP、Jep等。解释器模式一般用来解析比较标准的字符集，比如说SQL语法分析等。

解释器角色

解释器模式主要包含如下几个角色：

        AbstractExpression: 抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。

        TerminalExpression: 终结符表达式。实现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。文法中每一个终结符都有一个具体的终结表达式与之相对应。

        NonterminalExpression: 非终结符表达式。为文法中的非终结符相关的解释操作。

        Context: 环境类。包含解释器之外的一些全局信息。

        Client: 客户类。

      抽象语法树描述了如何构成一个复杂的句子，通过对抽象语法树的分析，可以识别出语言中的终结符和非终结符类。 在解释器模式中由于每一种终结符表达式、非终结符表达式都会有一个具体的实例与之相对应，所以系统的扩展性比较好。

案例解析

一个表达式求值得简单例子（借鉴了设计模式之禅中的代码）

public abstract class Expression {

	public abstract int interpreter(HashMap<String, Integer> var);
}

变量解析器

public class VarExpression extends Expression {

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

抽象运算符类

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

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

	@Override
	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])));
					break;
			}
		}
		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) {
		
		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) {
		HashMap<String, Integer> map = new HashMap<String, Integer>();
		
		for (char ch : expStr.toCharArray()) {
			if(ch != '+' && ch != '-') {
				if(!map.containsKey(String.valueOf(ch))) {
					System.out.println("输入表达式中符号" + ch + "代表的值：");
					Scanner scanner = new Scanner(System.in);
					int num = scanner.nextInt();
					map.put(String.valueOf(ch), num);
				}
			}
		}
		return map;
	}

	private static String getExpStr() {
		
		System.out.println("输入表达式：");
		Scanner scanner = new Scanner(System.in);
		return scanner.nextLine();
	}
}

解释器的优点

1、 可扩展性比较好，灵活。

2、 增加了新的解释表达式的方式。

3、 易于实现文法。

解释器的缺点

1、 执行效率比较低，可利用场景比较少。

2、 对于复杂的文法比较难维护。

解释器的适用场景

1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

2、一些重复出现的问题可以用一种简单的语言来进行表达。

3、文法较为简单。

设计模式源代码下载地址

设计模式源码下载地址