解释器模式
定义:给定一个语言,定义它的文法(语法)的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
为了解释一种语言,而为语言创建的解释器
类型:行为型
适用场景:(1)某个特定类型问题发生频率足够高
优点:(1)语法由很多类表示,容易改变及扩展此“语言”
缺点:(1)当语法规则数目太多时,增加了系统复杂度
不相同 | ||
适配器模式 | 不需要预先知道需要适配的规则 | |
解释器模式 | 把规则写好,根据规则去执行解释 |
代码
// 每个 class 都是一个 .java 文件
public interface Interpreter {
int interpret();
}
public class MultiInterpreter implements Interpreter {
private Interpreter firstExpression,secondExpression;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression){
this.firstExpression=firstExpression;
this.secondExpression=secondExpression;
}
@Override
public int interpret(){
return this.firstExpression.interpret()*this.secondExpression.interpret();
}
@Override
public String toString(){
return "*";
}
}
public class NumberInterpreter implements Interpreter {
private int number;
public NumberInterpreter(int number){
this.number=number;
}
public NumberInterpreter(String number){
this.number=Integer.parseInt(number);
}
@Override
public int interpret(){
return this.number;
}
}
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression,secondExpression;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression){
this.firstExpression=firstExpression;
this.secondExpression=secondExpression;
}
@Override
public int interpret(){
return this.firstExpression.interpret()+this.secondExpression.interpret();
}
@Override
public String toString(){
return "+";
}
}
public class GeelyExpressionParser {
private Stack<Interpreter> stack = new Stack<Interpreter>();
public int parse(String str) {
String[] strItemArray = str.split(" ");
for (String symbol : strItemArray) {
if (!OperatorUtil.isOperator(symbol)) {
Interpreter numberExpression = new NumberInterpreter(symbol);
stack.push(numberExpression);
System.out.println(String.format("入栈: %d", numberExpression.interpret()));
} else {
//是运算符号,可以计算
Interpreter firstExpression = stack.pop();
Interpreter secondExpression = stack.pop();
System.out.println(String.format("出栈: %d 和 %d",
firstExpression.interpret(), secondExpression.interpret()));
Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
System.out.println(String.format("应用运算符: %s", operator));
int result = operator.interpret();
NumberInterpreter resultExpression = new NumberInterpreter(result);
stack.push(resultExpression);
System.out.println(String.format("阶段结果入栈: %d", resultExpression.interpret()));
}
}
int result = stack.pop().interpret();
return result;
}
}
public class OperatorUtil {
public static boolean isOperator(String symbol) {
return (symbol.equals("+") || symbol.equals("*"));
}
public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
if (symbol.equals("+")) {
return new AddInterpreter(firstExpression, secondExpression);
} else if (symbol.equals("*")) {
return new MultiInterpreter(firstExpression, secondExpression);
}
return null;
}
}
// 测试代码
public class Test {
public static void main(String[] args) {
String geelyInputStr="6 100 11 + *";
GeelyExpressionParser expressionParser=new GeelyExpressionParser();
int result=expressionParser.parse(geelyInputStr);
System.out.println("解释器计算结果: "+result);
}
}
UML类图
源码示例
在 java.util 包中的 Pattern 类,
如 Spring 中的 ExpressionParser 接口