设计模式学习笔记——21 解释器模式

解释器模式

定义
给定一种语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子.

角色
AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。

TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。

NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。

Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。

优点
易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。

每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。

增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合 “开闭原则”。

缺点
对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

适用场景

1. 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
2. 一些重复出现的问题可以用一种简单的语言来进行表达。
3. 一个语言的文法较为简单。
4. 对执行效率要求不高。

UML类图：

代码实现：

public abstract class Expression {

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

public class VarExpression extends Expression {

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

	@Override
	public int interpret(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);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int interpret(HashMap<String, Integer> var) {
		// TODO Auto-generated method stub
		return super.left.interpret(var) + super.right.interpret(var);
	}

}

public class SubExpression extends SymbolExpression {

	public SubExpression(Expression left, Expression right) {
		super(left, right);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int interpret(HashMap<String, Integer> var) {
		// TODO Auto-generated method stub
		return super.left.interpret(var) - super.right.interpret(var);
	}

}

public class Calculator {

	private Expression exception;
	
	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.exception = stack.pop();
	}
	
	public int run(HashMap<String,Integer> var){
		return this.exception.interpret(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));

	}

	public 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))){
					try {
						String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
						map.put(String.valueOf(ch), Integer.valueOf(in));
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
		return map;
	}

	public static String getExpStr() {
		System.out.println("请输入表达式：");
		try {
			return (new BufferedReader(new InputStreamReader(System.in))).readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

}