设计模式（行为型设计模式——解释器模式）
解释器模式
基本定义
给分析对象定义一个语言，并定义该语言的文法表示，设计一个解析器来解释语言中的句子。
模式结构
AbstractExpression：抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。
TerminalExpression：终结符表达式。现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。解释结果。
NonterminalExpression：非终结符表达式。为文法中的非终结符相关的解释操作。一般情况下以子类的形式出现。
Context：环境类。包含解释器之外的一些全局信息。
Client: 客户端类
代码实现
AbstractExpression：抽象解释器
public interface Node {
int interpreter();
}
TerminalExpression：终结符表达式
/**
* 返回最终值
*/
public class ValueNode implements Node {
private int value;
public ValueNode(int value) {
this.value = value;
}
@Override
public int interpreter() {
return this.value;
}
}
NonterminalExpression：非终结符表达式
public class SymbolNode implements Node{
Node left;
Node right;
public SymbolNode(Node left, Node right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter() {
return 0;
}
}
/**
* 加法
*/
public class AddNode extends SymbolNode {
public AddNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpreter() {
return left.interpreter() + right.interpreter();
}
}
/**
* 减法
*/
public class SubtractNode extends SymbolNode {
public SubtractNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpreter() {
return left.interpreter() - right.interpreter();
}
}
/**
* 乘法
*/
public class MulNode extends SymbolNode {
public MulNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpreter() {
return left.interpreter() * right.interpreter();
}
}
/**
* 除法
*/
public class DivisionNode extends SymbolNode {
public DivisionNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpreter() {
return left.interpreter() / left.interpreter();
}
}
Context：环境类
public class Calculator {
private Node node;
private String statement;
public void build(String statement){
Node left = null;
Node right = null;
//提供容器，存储关系
Stack stack = new Stack();
//重点，将node存入stack, 存储前需确认表达式的顺序和执行结果
//以空格分隔
String[] statementArr = statement.split(" ");
int index = 0;
int value;
for (String state : statementArr){
index++;
switch (state){
case "*" ://乘法
left = (Node)stack.pop();
value = Integer.parseInt(statementArr[index]);
right = new ValueNode(value);
stack.push(new MulNode(left, right));
break;
case "/" : //除法
left = (Node)stack.pop();
value = Integer.parseInt(statementArr[index]);
right = new ValueNode(value);
stack.push(new DivisionNode(left, right));
break;
case "+" : //加法
left = (Node)stack.pop();
value = Integer.parseInt(statementArr[index]);
right = new ValueNode(value);
stack.push(new AddNode(left, right));
break;
case "-" : //减法
left = (Node)stack.pop();
value = Integer.parseInt(statementArr[index]);
right = new ValueNode(value);
stack.push(new SubtractNode(left, right));
break;
default:
stack.push(new ValueNode(Integer.parseInt(state)));
break;
}
}
//stack pop显示栈顶元素并且移除栈顶元素
this.node = (Node) stack.pop();
}
public int compute(){
return node.interpreter();
}
}
Client: 客户端类
@Slf4j
public class Test {
public static void main(String[] args){
//约定以空格分割
String statement = "3 * 2 / 2 + 1 - 2";
Calculator calculator = new Calculator();
calculator.build(statement);
int result = calculator.compute();
log.info("statement : {} ------> value = {}", statement, result);
}
}
优点
扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易
缺点
执行效率比较低，可利用场景比较少。
解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。
使用场景
当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。
当问题重复出现，且可以用一种简单的语言来进行表达时。
当语言的文法较为简单，且执行效率不是关键问题时。
模式总结
由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
虽然解释器的可扩展性强，但是如果语法规则的数目太大的时候，该模式可能就会变得异常复杂。所以解释器模式适用于文法较为简单的。
