feat: auto upload

src/SUMMARY.md

@@ -7,25 +7,39 @@
 
 ---
 
-- [Java SE](./bagu/JavaSE.md)
+- [Java SE 常考自检](./bagu/JavaSE自查版.md)
+
+- [Java SE](./bagu/JavaSE/README.md)
+  - [介绍一下 Java 语言](./bagu/JavaSE/介绍一下Java语言.md)
+  - [介绍一下 JDK、JRE 和 JVM](./bagu/JavaSE/JDK和JRE和JVM三者的关系.md)
+  - [创建 Java 对象有几种方式](./bagu/JavaSE/创建Java对象有几种方式.md)
+  - [说说你对 HashMap 数据结构的理解](./bagu/JavaSE/说说你对HashMap数据结构的理解.md)
+  - [什么是多态，你是怎么理解的](./bagu/JavaSE/什么是多态，你怎么理解的.md)
+
+
 - [MySQL](./bagu/MySQL.md)
+
 - [Collections](./bagu/collections/README.md)
-  - [ArrayList与LinkedList的区别](./bagu/collections/ArrayList与LinkedList区别.md)
+
+  - [ArrayList 与 LinkedList 的区别](./bagu/collections/ArrayList与LinkedList区别.md)
+
 - [JVM](./bagu/JVM/README.md)
-  - [JVM的类加载过程是怎么样的](./bagu/JVM/JVM的类加载过程是怎么样的.md)
-  - [JVM是如何创建对象的](./bagu/JVM/JVM是如何创建对象的.md)
-  - [JVM是如何实现的平台无关](./bagu/JVM/JVM是如何实现的平台无关.md)
-  - [JVM有哪些垃圾回收算法](./bagu/JVM/JVM有哪些垃圾回收算法.md)
+  - [JVM 的类加载过程是怎么样的](./bagu/JVM/JVM的类加载过程是怎么样的.md)
+  - [JVM 是如何创建对象的](./bagu/JVM/JVM是如何创建对象的.md)
+  - [JVM 是如何实现的平台无关](./bagu/JVM/JVM是如何实现的平台无关.md)
+  - [JVM 有哪些垃圾回收算法](./bagu/JVM/JVM有哪些垃圾回收算法.md)
+
 - [JUC](./bagu/JUC/README.md)
-  - [什么是Java内存模型](./bagu/JUC/什么是Java内存模型.md)
-  - [什么是ThreadLocal](./bagu/JUC/什么是ThreadLocal.md)
+  - [什么是 Java 内存模型](./bagu/JUC/什么是Java内存模型.md)
+  - [什么是 ThreadLocal](./bagu/JUC/什么是ThreadLocal.md)
   - [什么是死锁](./bagu/JUC/什么是死锁.md)
   - [什么是线程池](./bagu/JUC/什么是线程池.md)
+
 - [Spring](./bagu/Spring/README.md)
-  - [介绍一下IOC](./bagu/Spring/介绍一下IOC.md)
-  - [介绍一下AOP](./bagu/Spring/介绍一下AOP.md)
+  - [介绍一下 IOC](./bagu/Spring/介绍一下IOC.md)
+  - [介绍一下 AOP](./bagu/Spring/介绍一下AOP.md)
   - [用过哪些注解](./bagu/Spring/用过哪些注解.md)
-  - [Spring和SpringBoot的区别](./bagu/Spring/Spring和SpringBoot的区别.md)
+  - [Spring 和 SpringBoot 的区别](./bagu/Spring/Spring和SpringBoot的区别.md)
 
 # 面经篇
 

src/bagu/JavaSE/JDK和JRE和JVM三者的关系.md

@@ -0,0 +1,9 @@
+> JVM、JDK、JRE？
+
+JVM -- Java 虚拟机
+JRK -- Java 开发工具包
+JRE -- Java 运行环境
+
+三者之间的关系是：JDK > JRE > JVM
+
+## 

src/bagu/JavaSE/什么是多态，你怎么理解的.md

@@ -0,0 +1,77 @@
+> 什么是多态？
+
+多态就是，对于同一个父类，指向不同子类对象的同一个行为，运行出来结果不同。
+
+例如伪代码：
+
+```java
+class Animals {
+    public void sleep() {
+        sout("坐着睡！");
+    }
+}
+
+class Dog extends Animals {
+    @Override
+    public void sleep() {
+        sout("站立着睡！");
+    }
+}
+
+class Cat extends Animals {
+    @Override
+    public void sleep() {
+        sout("睁眼睡！");
+    }
+}
+// 同一个父类 Animals，指向不同子类 Dog、Cat
+Animals animals1 = new Dog();
+Animals animals2 = new Cat();
+```
+
+对于`animals1.sleep()`和`animals2.sleep()`，最后运行出来可能会有不用的结果，但是这取决于几个条件：
+
+- 继承类或实现接口
+
+- 子类重写方法
+
+- 同一个父类，指向不同子类
+
+> 重载与重写什么区别？
+
+引用 Wiki 百科：
+
+> ## 函数重载规则
+>
+> - 多个函数定义使用相同的函数名称
+> - 函数参数的数量或类型必须有区别
+>
+> 函数重载是静态多态的一种类别，其使用某种“最佳匹配”算法解析函数调用，通过找到形式参数类型与实际参数类型的最佳匹配来解析要调用的具体函数。该算法的细节因语言而异。
+>
+> 函数重载通常与[静态类型](https://zh.wikipedia.org/wiki/類型系統)编程语言（在[函数调用](https://zh.wikipedia.org/wiki/子程序)中强制执行[类型检查](https://zh.wikipedia.org/wiki/類型系統#型別檢查)）有关。重载函数实际上只是一组具有相同名称的不同函数。具体调用使用哪个函数是在[**编译期**](https://zh.wikipedia.org/wiki/编译期)决定的。
+>
+> 在 [Java](https://zh.wikipedia.org/wiki/Java) 中，函数重载也被称为编译时多态和静态多态。
+>
+> 函数重载不应与在运行时进行选择的[多态](https://zh.wikipedia.org/wiki/多态_(计算机科学))形式混淆，例如通过[虚函数](https://zh.wikipedia.org/wiki/虚函数)而不是静态函数。
+
+
+
+因此我们大概明白：
+
+- 重载是编译时重载的，编译时根据参数，决定调用哪个方法
+- 重写是运行期重写的，运行时根据父类指向的子类，调用方法
+
+
+
+**总结：**
+
+重载和重写都是多态的体现，维基百科中也有说明[多态分为动态多态和静态多态](https://zh.wikipedia.org/wiki/%E5%A4%9A%E6%80%81_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6))
+
+如图：
+
+![image-20231214103612773](https://cs-wlei224.obs.cn-south-1.myhuaweicloud.com/blog-imgs/202312141036730.png)
+
+
+
+那么我们不妨理解为重载为静态动态（编译器决定）、重写为运行期决定的，为动态多态。
+

src/bagu/JavaSE/介绍一下Java语言.md

@@ -0,0 +1,16 @@
+> 什么是 Java 语言？
+>
+
+WL: 
+
+Java 语言是一门面向对象的编程语言，不仅吸收了 C++ 语言的各种优点，还舍弃了 C++ 中难以理解的多继承以及指针的概念，因此 Java 语言功能强大且简单易用。Java 语言很好的实现了面向对象的思想，因此支持我们以优雅的思维方式进行复杂的编程。
+
+> Java 语言的特点？
+>
+
+WL: 
+
+1. 面向对象
+2. 平台无关
+3. 编译与解释并行
+4. 支持多线程

src/bagu/JavaSE/创建Java对象有几种方式.md

@@ -0,0 +1,67 @@
+> Java创建对象的几种方式？
+
+1. new
+
+2. 反射
+
+3. clone
+
+4. 序列化
+
+
+
+> 怎么理解反射？
+
+通过new来创建对象就是正射，是在编译时就会确定创建的对象类型；而反射就是动态地获取类信息、构造器进而`newInstance`创建对象的过程。
+
+> 怎么通过反射来创建一个对象？
+
+无参实例化：
+
+`Object obj = Class.forName(类名).getConstructor().newInstance();`
+
+有参实例化：
+
+`Object obj = Class.forName(类名).getConstructor(String.class).newInstance("汪汪");`
+
+```java
+public class Main {  
+    public static void main(String[] args) {  
+        try {  
+            // 获取Dog类的Class对象  
+            Class<?> dogClass = Class.forName("Dog");  
+
+            // 获取Dog类的构造器  
+            Constructor<?> dogConstructor = dogClass.getConstructor();  
+
+            // 通过构造器创建Dog对象  
+            Object dog = dogConstructor.newInstance();  
+
+            // 如果需要初始化参数，可以使用带有参数的构造函数  
+            Constructor<?> dogConstructorWithParams = dogClass.getConstructor(String.class);  
+            Object dogWithName = dogConstructorWithParams.newInstance("旺财");  
+
+        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {  
+            e.printStackTrace();  
+        }  
+    }  
+}  
+class Dog {  
+    private String name;  
+
+    public Dog() {  
+        name = "小黄学长";  
+    }  
+
+    public Dog(String name) {  
+        this.name = name;  
+    }  
+
+    public String getName() {  
+        return name;  
+    }  
+}
+```
+
+## 
+

src/bagu/JavaSE/说说你对HashMap数据结构的理解.md

@@ -0,0 +1,23 @@
+> 说说你对 HashMap 数据结构的理解？
+
+首先，hashmap 的数据结构是基于数组和链表的，如图：
+
+![img](https://cs-wlei224.obs.cn-south-1.myhuaweicloud.com/blog-imgs/202312070046177.png)
+
+so，既然是基于数组和链表的，那就说明数组和链表的特点也就是 HashMap 的特点：
+
+**数组：寻址快，直接根据索引访问元素，插入和删除慢；**
+
+**链表：寻址慢，需要从头节点开始遍历，插入和删除快。**
+
+
+
+说到 HashMap 就要说到 Java 8 了，Java 8 之前，HashMap 使用一个数组加链表的结构来存储 【K，V】 键值对。
+
+如果发生 hash 冲突，那么
+
+这将导致在处理 hash 冲突的时候性能不高，尤其是链表很长的时候。因此，Java 8 中的 HashMap 引入了红黑树来替代链表，这样当链表变长的时候，会自动转换为红黑树，从而提高了增删改查的性能。
+
+
+
+> 什么是 Hash 冲突？怎么解决？

src/bagu/JavaSE.md → src/bagu/JavaSE自查版.md

@@ -2,29 +2,14 @@
 
 什么是 Java 语言？
 
-WL: 
 
-Java 语言是一门面向对象的编程语言，不仅吸收了 C++ 语言的各种优点，还舍弃了 C++ 中难以理解的多继承以及指针的概念，因此 Java 语言功能强大且简单易用。Java 语言很好的实现了面向对象的思想，因此支持我们以优雅的思维方式进行复杂的编程。
 
 Java 语言的特点？
 
-WL: 
 
-1. 面向对象
-2. 平台无关
-3. 编译与解释并行
-4. 支持多线程
 
 JVM、JDK、JRE？
 
-WL: 
-
-JVM -- Java 虚拟机
-JRK -- Java 开发工具包
-JRE -- Java 运行环境
-
-三者之间的关系是：JDK > JRE > JVM
-
 ## Java基础
 
 1. Java有几种数据类型？分别是哪些？
@@ -43,10 +28,6 @@ System.out.println(i);
 4. 重写过`equals`和`hashcode`吗？为什么要重写？
 5. 解释一下深拷贝和浅拷贝。
 6. Java创建对象的几种方式？
-   1. new
-   2. 反射
-   3. clone
-   4. 序列化
 
 ## String
 
@@ -99,6 +80,7 @@ System.out.println(i);
 在IO流中，这种模式被广泛应用。例如，在java.io包中，InputStream和OutputStream是两个基础的输入输出流类，它们定义了输入输出流的基本行为和接口。然后，有许多其他的类和接口继承自InputStream和OutputStream，并添加了新的功能。这些新类可以看作是装饰器，它们可以增强原有类（被装饰类）的功能。例如，BufferedInputStream和BufferedOutputStream可以在原有类的基础上添加缓冲功能，提高IO性能。
 总的来说，装饰器模式是一种灵活且强大的设计模式，它允许我们在运行时动态地添加或删除功能，而无需修改原始的类。这种设计模式提高了代码的复用性和可扩展性。
 _**手撸装饰器模式：**_
+
 ```java
 public interface Printer {
     void print();
@@ -165,73 +147,12 @@ JSON序列化的方式有很多，一般会选择使用`jackson`包中的`Object
 
 1. 怎么理解反射？
 
-通过new来创建对象就是正射，是在编译时就会确定创建的对象类型；而反射就是动态地获取类信息、构造器进而`newInstance`创建对象的过程。
-
 2. 怎么通过反射来创建一个对象？
 
-无参实例化：`Object obj = Class.forName(类名).getConstructor().newInstance();`
-有参实例化：`Object obj = Class.forName(类名).getConstructor(String.class).newInstance("汪汪");`
-```java
-public class Main {  
-    public static void main(String[] args) {  
-        try {  
-            // 获取Dog类的Class对象  
-            Class<?> dogClass = Class.forName("Dog");  
-
-            // 获取Dog类的构造器  
-            Constructor<?> dogConstructor = dogClass.getConstructor();  
-
-            // 通过构造器创建Dog对象  
-            Object dog = dogConstructor.newInstance();  
-
-            // 如果需要初始化参数，可以使用带有参数的构造函数  
-            Constructor<?> dogConstructorWithParams = dogClass.getConstructor(String.class);  
-            Object dogWithName = dogConstructorWithParams.newInstance("旺财");  
-
-        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {  
-            e.printStackTrace();  
-        }  
-    }  
-}  
-class Dog {  
-    private String name;  
-
-    public Dog() {  
-        name = "小黄学长";  
-    }  
-
-    public Dog(String name) {  
-        this.name = name;  
-    }  
-
-    public String getName() {  
-        return name;  
-    }  
-}
-```
-
 ## 源码
 
 1. 说说你对 HashMap 数据结构的理解？
 
-首先，hashmap 的数据结构是基于数组和链表的，如图：
-
-![img](https://cs-wlei224.obs.cn-south-1.myhuaweicloud.com/blog-imgs/202312070046177.png)
-
-so，既然是基于数组和链表的，那就说明数组和链表的特点也就是 HashMap 的特点：
-
-**数组：寻址快，直接根据索引访问元素，插入和删除慢；**
-
-**链表：寻址慢，需要从头节点开始遍历，插入和删除快。**
-
-
-
-说到 HashMap 就要说到 Java 8 了，Java 8 之前，HashMap 使用一个数组加链表的结构来存储 【K，V】 键值对。
-
-如果发生 hash 冲突，那么
-
-这将导致在处理 hash 冲突的时候性能不高，尤其是链表很长的时候。因此，Java 8 中的 HashMap 引入了红黑树来替代链表，这样当链表变长的时候，会自动转换为红黑树，从而提高了增删改查的性能。
-
 
 
 2. 什么是 Hash 冲突？怎么解决？