定义
解释器模式提供了评估语言的语法或表达式的方式，它属于行为型模式。
这种模式实现了一个表达式接口，该接口解释一个特定的上下文。
这种模式被用在 SQL 解析、符号处理引擎等。
无论高级语言的程序是怎么样编写的，编译器的代码是不用修改的，而解释器模式就是想做一个建立在Java和我们自定义语言之间的编译器。
优缺点
优点：
- 可扩展性比较好，灵活。
- 增加了新的解释表达式的方式。
- 易于实现简单文法。
缺点：
- 可利用场景比较少。
- 对于复杂的文法比较难维护。
- 解释器模式会引起类膨胀。
- 解释器模式采用递归调用方法。
实现
抽象表示类Node
/**
* 抽象表示类Node
*/
public interface Node {
//解释当前结点，相当于计算当前结果
public int interpret();
}
终止符表达式类ValueNode
/**
* 终止符表达式类ValueNode
*/
public class ValueNode implements Node {
private int value;
public ValueNode(int value) {
this.value = value;
}
@Override
public int interpret() {
//因为当前终止符就是当前值的意思，所以直接返回当前值
return this.value;
}
}
非终止符表抽象类达式SymbolNode
/**
* 非终止符表达式抽象类SymbolNode
*/
public abstract class SymbolNode implements Node {
protected Node left;
protected Node right;
public SymbolNode(Node left, Node right) {
this.left = left;
this.right = right;
}
@Override
public abstract int interpret();
}
MulNode（乘法结点）
/**
* 非终止符表达式类 MulNode（乘法结点）
*/
public class MulNode extends SymbolNode {
public MulNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpret() {
return super.left.interpret() * super.right.interpret();
}
}
DivNode（除法结点）
/**
* 非终止符表达式类 DivNode（除法结点）
*/
public class DivNode extends SymbolNode {
public DivNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpret() {
return super.left.interpret() / super.right.interpret();
}
}
ModNode（求余结点）
/**
* 非终止符表达式类 ModNode（求余结点）
*/
public class ModNode extends SymbolNode {
public ModNode(Node left, Node right) {
super(left, right);
}
@Override
public int interpret() {
return super.left.interpret() % super.right.interpret();
}
}
解释器封装类
/**
* 解释器封装类
*/
public class Calculator {
//字符串表达式
private String statement;
private Node node;
public void build(String statement) {
Node left = null, right = null;
//存储中间生成的结点
Stack stack = new Stack();
String[] statementArr = statement.split(" ");
for (int i = 0; i < statementArr.length; i++) {
if (statementArr[i].equalsIgnoreCase("*")) {
//操作符，所以把左右两边的结点结合成一个结点
left = (Node) stack.pop();
int val = Integer.parseInt(statementArr[++i]);
right = new ValueNode(val);
stack.push(new MulNode(left, right));
} else if (statementArr[i].equalsIgnoreCase("/")) {
//操作符，所以把左右两边的结点结合成一个结点
left = (Node) stack.pop();
int val = Integer.parseInt(statementArr[++i]);
right = new ValueNode(val);
stack.push(new DivNode(left, right));
} else if (statementArr[i].equalsIgnoreCase("%")) {
//操作符，所以把左右两边的结点结合成一个结点
left = (Node) stack.pop();
int val = Integer.parseInt(statementArr[++i]);
right = new ValueNode(val);
stack.push(new ModNode(left, right));
} else {
//数值结点压入栈
stack.push(new ValueNode(Integer.parseInt(statementArr[i])));
}
}
//最后合成为一个结点
this.node = (Node) stack.pop();
}
public int compute() {
return node.interpret();
}
}
Main
public class Main {
public static void main(String args[]) {
String statement = "5 * 6 / 4 % 4";
Calculator c = new Calculator();
c.build(statement);
int result = c.compute();
System.out.println(statement + " = " + result);
}
}
---------结果---------
5 * 6 / 4 % 4 = 3
