JsoneJava
diff --git a/‎Java.md‎
Lines changed: 29 additions & 25 deletions b/‎Java.md‎
Lines changed: 29 additions & 25 deletions
@@ -786,7 +786,7 @@ public class MethodDemo {
 * 如果第 1 个阶段中没有找到适配的方法，那么在允许自动装拆箱，但不允许可变长参数的情况下选取重载方法
 * 如果第 2 个阶段中没有找到适配的方法，那么在允许自动装拆箱以及可变长参数的情况下选取重载方法
 
-如果 Java 编译器在同一个阶段中找到了多个适配的方法，那么会选择一个最为贴切的，而决定贴切程度的一个关键就是形式参数类型的继承关系，一般会选择形参为参数类型的子类的方法，因为子类时更具体的实现：
+如果 Java 编译器在同一个阶段中找到了多个适配的方法，那么会选择一个最为贴切的，而决定贴切程度的一个关键就是形式参数类型的继承关系，**一般会选择形参为参数类型的子类的方法，因为子类时更具体的实现**：
 
 ```java
 public class MethodDemo {
@@ -4318,19 +4318,19 @@ TreeSet 集合自排序的方式：
 2. 字符串类型的元素会按照首字符的编号排序
 3. 对于自定义的引用数据类型，TreeSet 默认无法排序，执行的时候报错，因为不知道排序规则
 
-自定义的引用数据类型，TreeSet 默认无法排序，需要定制排序的规则，方案有2种：
+自定义的引用数据类型，TreeSet 默认无法排序，需要定制排序的规则，方案有 2 种：
 
    * 直接为**对象的类**实现比较器规则接口 Comparable，重写比较方法：
 
-          方法：`public int compareTo(Employee o): this是比较者, o是被比较者`
+          方法：`public int compareTo(Employee o): this 是比较者, o 是被比较者`
 
-           * 比较者大于被比较者，返回正数
+           * 比较者大于被比较者，返回正数（升序）
            * 比较者小于被比较者，返回负数
            * 比较者等于被比较者，返回 0
 
    * 直接为**集合**设置比较器 Comparator 对象，重写比较方法：
 
-     方法：`public int compare(Employee o1, Employee o2): o1比较者, o2被比较者`
+     方法：`public int compare(Employee o1, Employee o2): o1 比较者, o2 被比较者`
 
      * 比较者大于被比较者，返回正数
      * 比较者小于被比较者，返回负数
@@ -8443,12 +8443,16 @@ public class AnnotationDemo01 {
 
 
 
+***
+
+
+
 #### 特殊属性
 
 注解的特殊属性名称：value
 
-* 如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写
-* 如果有多个属性，且多个属性没有默认值，那么value是不能省略的
+* 如果只有一个 value 属性的情况下，使用 value 属性的时候可以省略 value 名称不写
+* 如果有多个属性，且多个属性没有默认值，那么 value 是不能省略的
 
 ```java
 //@Book("/deleteBook.action")
@@ -8470,7 +8474,7 @@ public class AnnotationDemo01{
 
 ### 元注解
 
-元注解是sun公司提供的，用来注解自定义注解
+元注解是 sun 公司提供的，用来注解自定义注解
 
 元注解有四个：
 
@@ -11107,7 +11111,7 @@ Serial GC、Parallel GC、Concurrent Mark Sweep GC 这三个 GC  不同：
 
 ##### 静态集合
 
-静态集合类的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。原因是长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收
+静态集合类的生命周期与 JVM 程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。原因是**长生命周期的对象持有短生命周期对象的引用**，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收
 
 ```java
 public class MemoryLeak {
@@ -11184,7 +11188,7 @@ public class UsingRandom {
 
 ##### 改变哈希
 
-当一个对象被存储进 HashSet 集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段，否则对象修改后的哈希值与最初存储进 HashSet 集合中时的哈希值不同，这种情况下使用该对象的当前引用作为的参数去 HashSet 集合中检索对象返回 false，导致无法从 HashSet 集合中单独删除当前对象，造成内存泄漏
+当一个对象被存储进 HashSet 集合中以后，就**不能修改这个对象中的那些参与计算哈希值的字段**，否则对象修改后的哈希值与最初存储进 HashSet 集合中时的哈希值不同，这种情况下使用该对象的当前引用作为的参数去 HashSet 集合中检索对象返回 false，导致无法从 HashSet 集合中单独删除当前对象，造成内存泄漏
 
 
 
@@ -11280,14 +11284,14 @@ public Object pop() {
 
 * 普通对象：分为两部分
 
-  * Mark Word：用于存储对象自身的运行时数据， 如哈希码（HashCode）、GC 分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等等
+  * **Mark Word**：用于存储对象自身的运行时数据， 如哈希码（HashCode）、GC 分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等等
 
     ```ruby
     hash(25) + age(4) + lock(3) = 32bit					#32位系统
     unused(25+1) + hash(31) + age(4) + lock(3) = 64bit	#64位系统
     ```
 
-  * Klass Word：类型指针，对象指向它的类的元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例；在64位系统中，开启指针压缩（-XX:+UseCompressedOops）或者 JVM 堆的最大值小于 32G，这个指针也是 4byte，否则是 8byte（就是 Java 中的一个引用的大小）
+  * **Klass Word**：类型指针，指向该对象的类的元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例；在64位系统中，开启指针压缩（-XX:+UseCompressedOops）或者 JVM 堆的最大值小于 32G，这个指针也是 4byte，否则是 8byte（就是 Java 中的一个引用的大小）
 
   ```ruby
   |-----------------------------------------------------|
@@ -11309,7 +11313,7 @@ public Object pop() {
 
 实例数据：实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容，无论是从父类继承下来的，还是在子类中定义的，都需要记录起来
 
-对齐填充：Padding 起占位符的作用。64 位系统，由于 HotSpot VM 的自动内存管理系统要求对象起始地址必须是 8 字节的整数倍，就是对象的大小必须是 8 字节的整数倍，而对象头部分正好是 8 字节的倍数（1倍或者2倍），因此当对象实例数据部分没有对齐时，就需要通过对齐填充来补全
+对齐填充：Padding 起占位符的作用。64 位系统，由于 HotSpot VM 的自动内存管理系统要求**对象起始地址必须是 8 字节的整数倍**，就是对象的大小必须是 8 字节的整数倍，而对象头部分正好是 8 字节的倍数（1倍或者2倍），因此当对象实例数据部分没有对齐时，就需要通过对齐填充来补全
 
 32位系统：
 
@@ -11339,7 +11343,7 @@ public Object pop() {
 
 #### 实际大小
 
-浅堆（Shallow Heap）：对象本身占用的内存，不包括内部引用对象的大小，32 位系统中一个**对象引用占 4 个字节**，每个对象头占用 8 个字节，根据堆快照格式不同，对象的大小会同 8 字节进行对齐
+浅堆（Shallow Heap）：**对象本身占用的内存，不包括内部引用对象的大小**，32 位系统中一个**对象引用占 4 个字节**，每个对象头占用 8 个字节，根据堆快照格式不同，对象的大小会同 8 字节进行对齐
 
 JDK7 中的 String：2个 int 值共占 8 字节，value 对象引用占用 4 字节，对象头 8 字节，对齐后占 24 字节，为 String 对象的浅堆大小，与 value 实际取值无关，无论字符串长度如何，浅堆大小始终是 24 字节
 
@@ -11410,14 +11414,14 @@ private int hash32;
 
 JVM 是通过栈帧中的对象引用访问到其内部的对象实例：
 
-* 句柄访问
-  使用该方式，Java 堆中会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据和类型数据各自的具体地址信息
+* 句柄访问：Java 堆中会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据和类型数据各自的具体地址信息
+  
   优点：reference 中存储的是稳定的句柄地址，在对象被移动（垃圾收集）时只会改变句柄中的实例数据指针，而 reference 本身不需要被修改。
 
   <img src="https://gitee.com/seazean/images/raw/master/Java/JVM-对象访问-句柄访问.png" style="zoom: 50%;" />
 
-* 直接指针（HotSpot采用）
-  使用该方式，Java 堆对象的布局必须考虑如何放置访问类型数据的相关信息，reference中直接存储的就是对象地址
+* 直接指针（HotSpot采用）：Java 堆对象的布局必须考虑如何放置访问类型数据的相关信息，reference 中直接存储的对象地址
+  
   优点：速度更快，**节省了一次指针定位的时间开销**
 
   <img src="https://gitee.com/seazean/images/raw/master/Java/JVM-对象访问-直接指针.png" style="zoom: 67%;" />
@@ -11439,7 +11443,7 @@ JVM 是通过栈帧中的对象引用访问到其内部的对象实例：
 1.      创建阶段 (Created)：
 2.      应用阶段 (In Use)：对象至少被一个强引用持有着
 3.      不可见阶段 (Invisible)：程序的执行已经超出了该对象的作用域，不再持有该对象的任何强引用
-4.      不可达阶段 (Unreachable)：该对象不再被任何强引用所持有，包括GC Root的强引用
+4.      不可达阶段 (Unreachable)：该对象不再被任何强引用所持有，包括 GC Root 的强引用
 5.      收集阶段 (Collected)：垃圾回收器已经对该对象的内存空间重新分配做好准备，该对象如果重写了finalize()方法，则会去执行该方法
 6.      终结阶段 (Finalized)：等待垃圾回收器对该对象空间进行回收，当对象执行完finalize()方法后仍然处于不可达状态时进入该阶段
 7.      对象空间重分配阶段 (De-allocated)：垃圾回收器对该对象的所占用的内存空间进行回收或者再分配
@@ -11458,7 +11462,7 @@ JVM 是通过栈帧中的对象引用访问到其内部的对象实例：
 
 类在第一次实例化加载一次，后续实例化不再加载，引用第一次加载的类
 
-Java对象创建时机：
+Java 对象创建时机：
 
 1. 使用 new 关键字创建对象：由执行类实例创建表达式而引起的对象创建
 
@@ -11508,17 +11512,17 @@ Java对象创建时机：
 
 4. 初始化分配的空间：虚拟机将分配到的内存空间都初始化为零值（不包括对象头），保证对象实例字段在不赋值时可以直接使用，程序能访问到这些字段的数据类型所对应的零值
 
-5. 设置对象的对象头：将对象的所属类（类的元数据信息）、对象的HashCode、对象的GC信息、锁信息等数据存储在对象的对象头中
+5. 设置对象的对象头：将对象的所属类（类的元数据信息）、对象的 HashCode、对象的 GC 信息、锁信息等数据存储在对象头中
 
-6. 执行init方法进行实例化：实例变量初始化、实例代码块初始化 、构造函数初始化
+6. 执行 init 方法进行实例化：实例变量初始化、实例代码块初始化 、构造函数初始化
 
    * 实例变量初始化与实例代码块初始化：
 
-     对实例变量直接赋值或者使用实例代码块赋值，编译器会将其中的代码放到类的构造函数中去，并且这些代码会被放在对超类构造函数的调用语句之后 (**Java要求构造函数的第一条语句必须是超类构造函数的调用语句**)，构造函数本身的代码之前
+     对实例变量直接赋值或者使用实例代码块赋值，编译器会将其中的代码放到类的构造函数中去，并且这些代码会被放在对超类构造函数的调用语句之后 (**Java 要求构造函数的第一条语句必须是超类构造函数的调用语句**)，构造函数本身的代码之前
 
    * 构造函数初始化：
 
-     **Java要求在实例化类之前，必须先实例化其超类，以保证所创建实例的完整性**，在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到Object类。然后从Object类依次对以下各类进行实例化，初始化父类中的变量和执行构造函数
+     **Java 要求在实例化类之前，必须先实例化其超类，以保证所创建实例的完整性**，在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到 Object 类。然后从 Object 类依次对以下各类进行实例化，初始化父类中的变量和执行构造函数
 
 
 
@@ -18697,7 +18701,7 @@ private static final class ProxyClassFactory {
 
 #### CGLIB
 
-CGLIB 是一个功能强大，高性能的代码生成包，为没有实现接口的类提供代理，为 JDK 动态代理提供了补充
+CGLIB 是一个功能强大，高性能的代码生成包，为没有实现接口的类提供代理，为 JDK 动态代理提供了补充（$$Proxy）
 
 * CGLIB 是第三方提供的包，所以需要引入 jar 包的坐标：