设计模式：解释器模式模式
什么是解释器模式
解释器模式：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子。解释器模式是一种行为型模式。
解释器模式的结构
-
AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作。它是所有终结符表达式和非终结符表达式的父类。
-
TerminalExpression（终结符表达式）
-
NonterminalExpression（非终结符表达式）
-
Context（环境类）：用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。
在解释器模式中，每一种终结符和非终结符都有一个具体类与之对应。
解释器模式的一个实例
加减法计算器的实现。
实例代码
AbstractNode
public abstract class AbstractNode {
public abstract int interpret(Map<String,AbstractNode> variables);
}
ValueNode
public class ValueNode extends AbstractNode {
private int value;
public ValueNode(int value){
this.value = value;
}
@Override
public int interpret(Map<String,AbstractNode> variables) {
return value;
}
}
VariableNode
public class VariableNode extends AbstractNode {
private String name;
public VariableNode(String name){
this.name = name;
}
@Override
public int interpret(Map<String, AbstractNode> variables) {
if (null == variables.get(name)){
return 0;
}
return variables.get(name).interpret(variables);
}
}
MinusNode
public class MinusNode extends AbstractNode {
private AbstractNode left;
private AbstractNode right;
public MinusNode(AbstractNode left, AbstractNode right){
this.left = left;
this.right = right;
}
@Override
public int interpret(Map<String,AbstractNode> variables) {
return left.interpret(variables) - right.interpret(variables);
}
}
PlusNode
public class PlusNode extends AbstractNode {
private AbstractNode left;
private AbstractNode right;
public PlusNode(AbstractNode left, AbstractNode right){
this.left = left;
this.right = right;
}
@Override
public int interpret(Map<String,AbstractNode> variables) {
return left.interpret(variables) + right.interpret(variables);
}
}
Evaluator
public class Evaluator extends AbstractNode {
private AbstractNode expression;
private List<String> words;
public Evaluator(String text){
if (text != null && !"".equals(text.trim())) {
text = text.replace(" ", "");
Stack<AbstractNode> stack = new Stack<AbstractNode>();
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if ('+' == c) {
AbstractNode plusNode = new PlusNode(stack.pop(), new VariableNode(String.valueOf(text.charAt(++i))));
stack.push(plusNode);
} else if ('-' == c) {
AbstractNode minusNode = new MinusNode(stack.pop(), new VariableNode(String.valueOf(text.charAt(++i))));
stack.push(minusNode);
} else {
stack.push(new VariableNode(String.valueOf(c)));
}
}
expression = stack.pop();
}
}
@Override
public int interpret(Map<String,AbstractNode> variables) {
return expression.interpret(variables);
}
}
Client
public class Client {
public static void main(String[] args){
Evaluator evaluator = new Evaluator("x - y + z - y + x");
Map<String,AbstractNode> abstractNodeMap = new HashMap<String,AbstractNode>();
abstractNodeMap.put("x",new ValueNode(16));
abstractNodeMap.put("y",new ValueNode(6));
abstractNodeMap.put("z",new ValueNode(6));
int result = evaluator.interpret(abstractNodeMap);
System.out.println(result);
}
}
实例结果
26
（完）