java重要知识点

Author: itwanger

README.md

@@ -191,26 +191,26 @@
 ## Java重要知识点
 
 - [彻底弄懂Java中的Unicode和UTF-8编码](docs/basic-extra-meal/java-unicode.md)
-- [Java中int、Integer、new Integer之间的区别](docs/basic-extra-meal/int-cache.md)
+- [Java中new Integer与Integer.valueOf的区别](docs/basic-extra-meal/int-cache.md)
 - [深入剖析Java中的拆箱和装箱](docs/basic-extra-meal/box.md)
-- [彻底讲明白的Java浅拷贝与深拷贝](docs/basic-extra-meal/deep-copy.md)
+- [一文彻底讲明白的Java中的浅拷贝与深拷贝](docs/basic-extra-meal/deep-copy.md)
 - [深入理解Java中的hashCode方法](docs/basic-extra-meal/hashcode.md)
-- [一次性搞清楚equals和hashCode](docs/basic-extra-meal/equals-hashcode.md)
+- [为什么重写equals方法的时候必须要重写hashCode方法？](docs/basic-extra-meal/equals-hashcode.md)
 - [Java重写（Overriding）时应当遵守的11条规则](docs/basic-extra-meal/Overriding.md)
 - [Java到底是值传递还是引用传递？](docs/basic-extra-meal/pass-by-value.md)
-- [Java不能实现真正泛型的原因是什么？](docs/basic-extra-meal/true-generic.md)
-- [详解Java中Comparable和Comparator的区别](docs/basic-extra-meal/comparable-omparator.md)
-- [jdk9为何要将String的底层实现由char[]改成了byte[]?](docs/basic-extra-meal/jdk9-char-byte-string.md)
+- [详解Java中Comparable和Comparator接口的区别](docs/basic-extra-meal/comparable-omparator.md)
+- [jdk9为什么要将String的底层实现由char数组改成了byte数组?](docs/basic-extra-meal/jdk9-char-byte-string.md)
 - [为什么JDK源码中，无限循环大多使用for(;;)而不是while(true)?](docs/basic-extra-meal/jdk-while-for-wuxian-xunhuan.md)
-- [先有Class还是先有Object？](docs/basic-extra-meal/class-object.md)
+- [Java 中，先有Class还是先有Object？](docs/basic-extra-meal/class-object.md)
+- [详解Java中instanceof关键字的用法](docs/oo/instanceof.md)
 - [instanceof关键字是如何实现的？](docs/basic-extra-meal/instanceof-jvm.md)
-- [Java instanceof关键字用法](docs/oo/instanceof.md)
 - [深入理解Java中的不可变对象](docs/basic-extra-meal/immutable.md)
 - [Java中可变参数的使用](docs/basic-extra-meal/varables.md)
-- [深入理解Java泛型](docs/basic-extra-meal/generic.md)
-- [深入理解Java注解](docs/basic-extra-meal/annotation.md)
-- [Java枚举（enum）](docs/basic-extra-meal/enum.md)
-- [大白话说Java反射：入门、使用、原理](docs/basic-extra-meal/fanshe.md)
+- [深入理解Java中的泛型](docs/basic-extra-meal/generic.md)
+- [Java不能实现真正泛型的原因是什么？](docs/basic-extra-meal/true-generic.md)
+- [深入理解Java中的注解](docs/basic-extra-meal/annotation.md)
+- [新来个技术总监，彻底把 Java 枚举(enum)讲清楚了](docs/basic-extra-meal/enum.md)
+- [大白话说清楚Java反射：入门、使用、原理](docs/basic-extra-meal/fanshe.md)
 
 ## Java网络编程
 

docs/.vuepress/sidebar.ts

@@ -198,90 +198,27 @@ export const sidebarConfig = sidebar({
           prefix:"basic-extra-meal/",
           collapsable: true,
           children: [
-          {
-            text: "Unicode和UTF-8编码",
-            link: "java-unicode",
-          },
-          {
-            text: "new Integer和Integer.valueOf区别",
-            link: "int-cache",
-          },
-          {
-            text: "拆箱和装箱",
-            link: "box",
-          },
-          {
-            text: "浅拷贝与深拷贝",
-            link: "deep-copy",
-          },
-          {
-            text: "深入理解Java中的hashCode方法",
-            link: "hashcode",
-          },
-          {
-            text: "重写equals时为什么要重写hashCode",
-            link: "equals-hashcode",
-          },
-          {
-            text: "重写时应当遵守的11条规则",
-            link: "Overriding",
-          },
-          {
-            text: "Java到底是值传递还是引用传递",
-            link: "pass-by-value",
-          },
-          {
-            text: "Java为什么不能实现真正的泛型",
-            link: "true-generic",
-          },
-          {
-            text: "Comparable和Comparator的区别",
-            link: "comparable-omparator",
-          },
-          {
-            text: "JDK9中String为什么由char[]改成byte[]",
-            link: "jdk9-char-byte-string",
-          },
-          {
-            text: "JDK源码无限循环用for(;;)还是while(true)",
-            link: "jdk-while-for-wuxian-xunhuan",
-          },
-          {
-            text: "先有Class还是先有Object",
-            link: "class-object",
-          },
-          {
-            text: "instanceof关键字是如何实现的",
-            link: "instanceof-jvm",
-          },
-          {
-            text: "instanceof",
-            link: "oo/instanceof",
-          },
-          {
-            text: "不可变对象",
-            link: "basic-extra-meal/immutable",
-          },
-          {
-            text: "可变参数",
-            link: "basic-extra-meal/varables",
-          },
-          {
-            text: "泛型",
-            link: "basic-extra-meal/generic",
-          },
-          {
-            text: "注解",
-            link: "basic-extra-meal/annotation",
-          },
-          {
-            text: "枚举",
-            link: "basic-extra-meal/enum",
-          },
-          {
-            text: "反射",
-            link: "basic-extra-meal/fanshe",
-          },
+          "java-unicode",
+          "int-cache",
+          "box",
+          "deep-copy",
+          "hashcode",
+          "equals-hashcode",
+          "Overriding",
+          "pass-by-value",
+          "comparable-omparator",
+          "jdk9-char-byte-string",
+          "jdk-while-for-wuxian-xunhuan",
+          "class-object",
+          "instanceof",
+          "instanceof-jvm",
+          "immutable"
+          "varables",
+          "generic",
+          "true-generic",
+          "annotation",
+          "enum",
+          "fanshe",
           ],
         },
         {

docs/basic-extra-meal/Overriding.md

@@ -1,25 +1,31 @@
 ---
+title: Java重写（Overriding）时应当遵守的11条规则
+shortTitle: 重写时应当遵守的11条规则
 category:
   - Java核心
 tag:
-  - Java
+  - Java重要知识点
+description: Java程序员进阶之路，小白的零基础Java教程，从入门到进阶，Java重写（Overriding）时应当遵守的11条规则
+head:
+  - - meta
+    - name: keywords
+      content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,重写,Overriding
 ---
 
-# Java重写（Overriding）时应当遵守的11条规则
 
 重写（Overriding）算是 Java 中一个非常重要的概念，理解重写到底是什么对每个 Java 程序员来说都至关重要，这篇文章就来给大家说说重写过程中应当遵守的 12 条规则。
 
-### 01、什么是重写？
+## 01、什么是重写？
 
 重写带来了一种非常重要的能力，可以让子类重新实现从超类那继承过来的方法。在下面这幅图中，Animal 是父类，Dog 是子类，Dog 重新实现了 `move()` 方法用来和父类进行区分，毕竟狗狗跑起来还是比较有特色的。
 
 ![](http://cdn.tobebetterjavaer.com/tobebetterjavaer/images/basic-extra-meal/Overriding-1.png)
 
 重写的方法和被重写的方法，不仅方法名相同，参数也相同，只不过，方法体有所不同。
 
-### 02、哪些方法可以被重写？
+## 02、哪些方法可以被重写？
 
-**规则一：只能重写继承过来的方法**。
+### **规则一：只能重写继承过来的方法**。
 
 因为重写是在子类重新实现从父类继承过来的方法时发生的，所以只能重写继承过来的方法，这很好理解。这就意味着，只能重写那些被 public、protected 或者 default 修饰的方法，private 修饰的方法无法被重写。
 
@@ -63,9 +69,9 @@ public class Dog extends Animal {
 }
 ```
 
-### 03、哪些方法不能被重写？
+## 03、哪些方法不能被重写？
 
-**规则二：final、static 的方法不能被重写**。
+### **规则二：final、static 的方法不能被重写**。
 
 一个方法是 final 的就意味着它无法被子类继承到，所以就没办法重写。
 
@@ -91,9 +97,9 @@ public class Animal {
 
 ![](http://cdn.tobebetterjavaer.com/tobebetterjavaer/images/basic-extra-meal/Overriding-3.png)
 
-### 04、重写方法的要求
+## 04、重写方法的要求
 
-**规则三：重写的方法必须有相同的参数列表**。
+### **规则三：重写的方法必须有相同的参数列表**。
 
 ```java
 public class Animal {
@@ -143,7 +149,7 @@ public class Dog extends Animal {
 
 ![](http://cdn.tobebetterjavaer.com/tobebetterjavaer/images/basic-extra-meal/Overriding-4.png)
 
-**规则五：重写的方法不能使用限制等级更严格的权限修饰符**。
+### **规则五：重写的方法不能使用限制等级更严格的权限修饰符**。
 
 可以这样来理解：
 
@@ -171,7 +177,7 @@ public class Dog extends Animal {
 
 ![](http://cdn.tobebetterjavaer.com/tobebetterjavaer/images/basic-extra-meal/Overriding-5.png)
 
-**规则六：重写后的方法不能抛出比父类中更高级别的异常**。
+### **规则六：重写后的方法不能抛出比父类中更高级别的异常**。
 
 举例来说，如果父类中的方法抛出的是 IOException，那么子类中重写的方法不能抛出 Exception，可以是 IOException 的子类或者不抛出任何异常。这条规则只适用于可检查的异常。
 
@@ -231,9 +237,9 @@ Error:(9, 16) java: com.itwanger.overriding.Dog中的eat()无法覆盖com.itwang
   被覆盖的方法未抛出java.lang.Exception
 ```
 
-### 05、如何调用被重写的方法？
+## 05、如何调用被重写的方法？
 
-**规则七：可以在子类中通过 super 关键字来调用父类中被重写的方法**。
+### **规则七：可以在子类中通过 super 关键字来调用父类中被重写的方法**。
 
 子类继承父类的方法而不是重新实现是很常见的一种做法，在这种情况下，可以按照下面的形式调用父类的方法：
 
@@ -260,15 +266,15 @@ public class Dog extends Animal {
 }
 ```
 
-### 06、重写和构造方法
+## 06、重写和构造方法
 
-**规则八：构造方法不能被重写**。
+### **规则八：构造方法不能被重写**。
 
 因为构造方法很特殊，而且子类的构造方法不能和父类的构造方法同名（类名不同），所以构造方法和重写之间没有任何关系。
 
-### 07、重写和抽象方法
+## 07、重写和抽象方法
 
-**规则九：如果一个类继承了抽象类，抽象类中的抽象方法必须在子类中被重写**。
+### **规则九：如果一个类继承了抽象类，抽象类中的抽象方法必须在子类中被重写**。
 
 先来看这样一个接口类：
 
@@ -306,15 +312,15 @@ public class BullDog extends AbstractDog {
 }
 ```
 
-### 08、重写和 synchronized 方法
+## 08、重写和 synchronized 方法
 
-**规则十：synchronized 关键字对重写规则没有任何影响**。
+### **规则十：synchronized 关键字对重写规则没有任何影响**。
 
 synchronized 关键字用于在多线程环境中获取和释放监听对象，因此它对重写规则没有任何影响，这就意味着 synchronized 方法可以去重写一个非同步方法。
 
-### 09、重写和 strictfp 方法
+## 09、重写和 strictfp 方法
 
-**规则十一：strictfp 关键字对重写规则没有任何影响**。
+### **规则十一：strictfp 关键字对重写规则没有任何影响**。
 
 如果你想让浮点运算更加精确，而且不会因为硬件平台的不同导致执行的结果不一致的话，可以在方法上添加 strictfp 关键字。因此 strictfp 关键和重写规则无关。
 

docs/basic-extra-meal/annotation.md

@@ -1,12 +1,17 @@
 ---
+title: 深入理解Java中的注解
+shortTitle: 深入理解Java中的注解
 category:
   - Java核心
 tag:
-  - Java
+  - Java重要知识点
+description: Java程序员进阶之路，小白的零基础Java教程，从入门到进阶，深入理解Java中的注解
+head:
+  - - meta
+    - name: keywords
+      content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,注解,annotation
 ---
 
-# 深入理解Java注解
-
 “二哥，这节讲注解吗？”三妹问。
 
 “是的。”我说，“注解是 Java 中非常重要的一部分，但经常被忽视也是真的。之所以这么说是因为我们更倾向成为一名注解的使用者而不是创建者。`@Override` 注解用过吧？但你知道怎么自定义一个注解吗？”

docs/basic-extra-meal/box.md

@@ -1,11 +1,17 @@
 ---
+title: 深入剖析Java中的拆箱和装箱
+shortTitle: 深入剖析Java中的拆箱和装箱
 category:
   - Java核心
 tag:
-  - Java
+  - Java重要知识点
+description: Java程序员进阶之路，小白的零基础Java教程，从入门到进阶，深入剖析Java中的拆箱和装箱
+head:
+  - - meta
+    - name: keywords
+      content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,装箱,拆箱,包装类型
 ---
 
-# 深入剖析Java中的拆箱和装箱
 
 “哥，听说 Java 的每个基本类型都对应了一个包装类型，比如说 int 的包装类型为 Integer，double 的包装类型为 Double，是这样吗？”从三妹这句话当中，能听得出来，她已经提前预习这块内容了。
 

docs/basic-extra-meal/class-object.md

@@ -1,11 +1,18 @@
 ---
+title: Java 中，先有Class还是先有Object？
+shortTitle: 先有Class还是先有Object？
 category:
   - Java核心
 tag:
-  - Java
+  - Java重要知识点
+description: Java程序员进阶之路，小白的零基础Java教程，从入门到进阶，Java 中，先有Class还是先有Object？
+head:
+  - - meta
+    - name: keywords
+      content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,class,object
 ---
 
-# 先有Class还是先有Object？
+
 
 Java 对象模型中：
 
@@ -18,7 +25,7 @@ Java 对象模型中：
 
 针对这个问题，我在知乎上看到了 R 大的一个回答，正好解答了我心中的疑惑，就分享出来给各位小伙伴一个参考和启发~
 
->作者：RednaxelaFX，整理：沉默王二，参考链接：https://www.zhihu.com/question/30301819/answer/47539163
+>作者：RednaxelaFX，整理：沉默王二，参考链接：[https://www.zhihu.com/question/30301819/answer/47539163](https://www.zhihu.com/question/30301819/answer/47539163)
 
 -----