本设计模式资料源于慕课网,讲师:Geely 《Java设计模式精讲 Debug方式+内存分析》,本人作为自己手打整理作为学习的归纳总结。
一,模式介绍
1,定义和类型
- 定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中句子
- 为了解释一种语言,而为语言创建的解释器
- 类型:行为型
2,适用场景
- 某个特定类型问题发生频率足够高
3,优点
- 语法由很多类表示,容易改变及扩展此“语言”
4,缺点
- 当语法规则数目太多时,增加了系统复杂度
5,相关设计模式
- 解释器模式和适配器模式
二,代码演示
- 业务场景
将一段含有加减乘除的字符串计算后进行输出
首先是测试类
package com.try1.design.behavioral.interpreter;
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);
}
}
第一个栈处理类
package com.try1.design.behavioral.interpreter;
import java.util.Stack;
public class GeelyExpressionParser {
private Stack<Interpreter> stack= new Stack<>();
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;
}
}
上面这个类的主要作用是集合各种工具类,首先将字符串分割,再来是判断是否是运算符,不是则将其压入堆栈,是运算符则,弹出两个数进行对应的运算。
下面给出对应的工具类
判断类
package com.try1.design.behavioral.interpreter;
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;
}
}
关联类对应接口
package com.try1.design.behavioral.interpreter;
public interface Interpreter {
int interpret();
}
非运算符转化类
package com.try1.design.behavioral.interpreter;
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;
}
}
乘法处理类
package com.try1.design.behavioral.interpreter;
public class MultiInterpreter implements Interpreter{
private Interpreter firstExpression,secondExprssion;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExprssion) {
this.firstExpression = firstExpression;
this.secondExprssion = secondExprssion;
}
@Override
public int interpret() {
return this.firstExpression.interpret()*this.secondExprssion.interpret();
}
@Override
public String toString() {
return "*";
}
}
加法处理类
package com.try1.design.behavioral.interpreter;
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression,secondExprssion;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExprssion) {
this.firstExpression = firstExpression;
this.secondExprssion = secondExprssion;
}
@Override
public int interpret() {
return this.firstExpression.interpret()+this.secondExprssion.interpret();
}
@Override
public String toString() {
return "+";
}
}
运行截图
下面是 spring 自带的一个解释器
package com.try1.design.behavioral.interpreter;
public class SpringTest {
public static void main(String[] args) {
// org.springframework.expression.ExpressionParser parser=new SpelExpressionParser();
// Expression expression=parser.parseExpression("100 * 2 + 400 * 1 + 66");
// int result=(Integer)expression.getValue();
// System.out.println(result);
}
}
三,总结
- 其实总的来说,该设计模式只让我想到了之前算法课上学到的跟这个很类似的,一个实现计算器的代码格式,这个里面则是将每个的返回值进行了,统一和规整。
- 解释器应该能应用于某个大型的处理步骤中。