【设计模式】解释器模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
【摘要】
文章目录
一、解释器模式简介二、解释器模式适用场景三、解释器模式优缺点四、解释器模式与适配器模式五、解释器模式代码示例1、解释器接口2、加法解释器3、乘法解释器4、整型解释器5、语法解析类6、工具...
一、解释器模式简介
解释器模式 : 给定一个 语言 , 定义它的 文法 的一种表示 , 并定义一个 解释器 , 这个 解释器 使用该表示来 解释 语言中的 句子 ;
文法 可以理解成一种 语法 ;
为了解释一种语言 , 而为语言创建的 解释器 ;
如 : Java 代码 , 需要编译器进行编译之后才能运行 , 这个编译器就相当于解释器 ;
解释器模式类型 : 行为型 ;
二、解释器模式适用场景
解释器模式适用场景 : 某个 特定类型问题 发生频率 足够高 ;
日志处理 : 使用 脚本语言 或 编程语言 处理日志时 , 有很多服务 会产生 大量的日志 , 需要 对日志进行解析 , 生成报表 ;
各个服务的日志格式不同 , 数据中的要素相同 , 这种情况下 , 通过程序解决上述问题 , 主要的解决方案就是使用解释器模式 ;
日常项目中 , 解释器模式使用情况很少 ;
解释器一般是 开源包 , 如 Express4J , JEP ;
三、解释器模式优缺点
解释器模式优点 : 语法 由 很多类 表示 , 容易 改变 及 扩展 " 语言 " ;
" 语言 " 用引号标注 , 这些语言不足以称为一门 编程语言 ;
解释器模式缺点 : 如果 语法规则 数目太多 , 会增加 系统 复杂度 ;
每个规则 都要与之对应 一个类 , 如果规则太多 , 则需要创建很多类 ;
解释器模式在实际业务中 , 是使用频率很低的设计模式 ;
四、解释器模式与适配器模式
解释器模式与适配器模式 : 这两个模式类似 , 但是略有不同 ;
-
适配器模式 : 不需要 预先知道 适配器的 规则 ;
-
解释器模式 : 需要 预先将规则写好 , 根据规则执行解释 ;
五、解释器模式代码示例
业务场景 :
输入字符串
10 2 3 + *
- 1
将字符串使用空格切割成数组
遇到数字直接入栈
遇到运算符 , 从栈中取出两个数据 , 进行计算 , 将计算结果再放入栈中
遍历完毕后 , 最终的栈内数据就是最终结果
1、解释器接口
package interpreter;
/**
* 解释器接口
*/
public interface Interpreter {
/**
* 解释方法
* @return
*/
int interpret();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
2、加法解释器
package interpreter;
/**
* 加法解释器
* 实现 Interpreter 解释器 接口
* 用于实现加法计算
* 加法有加数 和 被加数 , 两个加数分别也都是一个解释器
*/
public class AddInterpreter implements Interpreter {
/**
* 第一个表达式
*/
private Interpreter firstInterpreter;
/**
* 第二个表达式
*/
private Interpreter secondInterpreter;
public AddInterpreter(Interpreter firstInterpreter,
Interpreter secondInterpreter) {
this.firstInterpreter = firstInterpreter;
this.secondInterpreter = secondInterpreter;
}
@Override
public int interpret() {
return this.firstInterpreter.interpret() +
this.secondInterpreter.interpret();
}
@Override
public String toString() {
return "+";
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
3、乘法解释器
package interpreter;
/**
* 乘法解释器
* 实现 Interpreter 解释器 接口
* 用于实现乘法计算
* 两个乘数分别也都是一个解释器
*/
public class MultiInterpreter implements Interpreter {
/**
* 第一个表达式
*/
private Interpreter firstInterpreter;
/**
* 第二个表达式
*/
private Interpreter secondInterpreter;
public MultiInterpreter(Interpreter firstInterpreter,
Interpreter secondInterpreter) {
this.firstInterpreter = firstInterpreter;
this.secondInterpreter = secondInterpreter;
}
@Override
public int interpret() {
return this.firstInterpreter.interpret() *
this.secondInterpreter.interpret();
}
@Override
public String toString() {
return "*";
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
4、整型解释器
package interpreter;
/**
* 数字解释器
* 实现 Interpreter 解释器 接口
*/
public class NumberInterpreter implements Interpreter {
/**
* 核心数字
* 需要将传入的数据转为数字
*/
private int number;
/**
* 直接设置数字类型
* @param number
*/
public NumberInterpreter(int number) {
this.number = number;
}
/**
* 将字符串转为数字类型
* @param number
*/
public NumberInterpreter(String number) {
this.number = Integer.parseInt(number);
}
@Override
public int interpret() {
return this.number;
}
@Override
public String toString() {
return "" + this.number;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
5、语法解析类
package interpreter;
import java.util.Stack;
/**
* 语法解析
*/
public class ExpressionParser {
/**
* 存放解释器的栈
* 栈的特点是先进后出
*/
private Stack<Interpreter> stack = new Stack<>();
/**
* 解析字符串语法
* @param str
*/
public void parse(String str) {
// 通过空格分割字符串
String[] strArray = str.split(" ");
// 遍历栈中的字符串
for (String symbol : strArray) {
if (!OperatorUtils.isOperator(symbol)) {
// 如果不是操作符 , 说明是数字 , 则直接入栈
Interpreter interpreter = new NumberInterpreter(symbol);
stack.push(interpreter);
System.out.println(symbol + " 入栈");
} else {
// 如果是操作符 , 则数据出栈 , 处理是操作符运算的情况
// 取出两个需要计算的元素
Interpreter firstInterpreter = stack.pop();
System.out.println(firstInterpreter + " 出栈");
Interpreter secondInterpreter = stack.pop();
System.out.println(secondInterpreter + " 出栈");
// 获取 运算符号 对应的解释器
Interpreter operator = OperatorUtils.
getExpressionInterpretor(
symbol,
firstInterpreter,
secondInterpreter);
System.out.println("运算符 " + operator + " 出栈");
// 计算 运算符 运算结果
int result = operator.interpret();
// 将计算结果你年入栈
NumberInterpreter numberInterpreter = new NumberInterpreter(result);
stack.push(numberInterpreter);
System.out.println("计算结果 " + result + " 入栈");
}
}
// 取出最终计算结果 , 计算完毕后 , 整个栈必然只剩下一个元素
int result = stack.pop().interpret();
System.out.println("最终计算结果 : " + result);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
6、工具类
package interpreter;
public class OperatorUtils {
/**
* 判断传入的符号字符串是否是操作符
* @param symbol
* @return
*/
public static boolean isOperator(String symbol) {
return symbol.equals("+") || symbol.equals("*");
}
public static Interpreter getExpressionInterpretor(
String symbol,
Interpreter firstInterpreter,
Interpreter secondInterpreter) {
Interpreter interpreter = null;
if (symbol.equals("+")) {
interpreter = new AddInterpreter(firstInterpreter, secondInterpreter);
} else if (symbol.equals("*")) {
interpreter = new MultiInterpreter(firstInterpreter, secondInterpreter);
}
return interpreter;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
7、测试类
package interpreter;
public class Main {
public static void main(String[] args) {
// 将字符串使用空格切割成数组
// 遇到数字直接入栈
// 遇到运算符 , 从栈中取出两个数据 , 进行计算 , 将计算结果再放入栈中
// 遍历完毕后 , 最终的栈内数据就是最终结果
String text = "10 2 3 + *";
ExpressionParser parser = new ExpressionParser();
parser.parse(text);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
执行结果 :
10 入栈
2 入栈
3 入栈
3 出栈
2 出栈
运算符 + 出栈
计算结果 5 入栈
5 出栈
10 出栈
运算符 * 出栈
计算结果 50 入栈
最终计算结果 : 50
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。
原文链接：hanshuliang.blog.csdn.net/article/details/119752572
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）