解析器是一种按照规定的语法进行解析的例子，在现在的项目中使用较少，定义如下：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器用于解释语言中的句子。
个人理解
解释器模式在项目中很少使用，因为他会引起效率、性能以及维护等问题，准备使用该模式时可以考虑开源框架如：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、文法较为简单。