修正一些错别字

lowking · lowking · commit 5d640559c453 · 2022-02-14T13:15:19.000+08:00
diff --git a/docs/advance/design-patterns/abstract-factory-pattern.md b/docs/advance/design-patterns/abstract-factory-pattern.md
@@ -36,7 +36,7 @@
 > 
 > Product(具体产品)：定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
 
-本文的例子采用一个汽车代工厂造汽车的例子。假设我们是一家汽车代工厂商，我们负责给奔驰和特斯拉两家公司制造车子。我们简单的把奔驰车理解为需要加油的车，特斯拉为需要充电的车。其中奔驰车中包含跑车和商务车两种，特斯拉同样也包含奔驰车和商务车。
+本文的例子采用一个汽车代工厂造汽车的例子。假设我们是一家汽车代工厂商，我们负责给奔驰和特斯拉两家公司制造车子。我们简单的把奔驰车理解为需要加油的车，特斯拉为需要充电的车。其中奔驰车中包含跑车和商务车两种，特斯拉同样也包含跑车和商务车。
 
 [<img src="http://www.hollischuang.com/wp-content/uploads/2016/04/QQ20160419-1.png" alt="QQ20160419-1" width="657" height="554" class="alignnone size-full wp-image-1422" />][6]
 
diff --git a/docs/advance/design-patterns/adapter-pattern.md b/docs/advance/design-patterns/adapter-pattern.md
@@ -125,7 +125,7 @@ GOF中将适配器模式分为类适配器模式和对象适配器模式。区
         public void charge(){
             System.out.println("开始给我的GalaxyS7手机充电...");
             microUsbInterface.chargeWithMicroUsb();
-            System.out.println("开始给我的GalaxyS7手机充电...");
+            System.out.println("结束给我的GalaxyS7手机充电...");
         }
     
         public MicroUsbInterface getMicroUsbInterface() {
@@ -203,14 +203,14 @@ GOF中将适配器模式分为类适配器模式和对象适配器模式。区
     ==============================
     开始给我的GalaxyS7手机充电...
     使用MicroUsb型号的充电器充电...
-    开始给我的GalaxyS7手机充电...
+    结束给我的GalaxyS7手机充电...
     ==============================
     开始给我的Iphone6Plus手机充电...
     使用MicroUsb型号的充电器充电...
     结束给我的Iphone6Plus手机充电...
     
 
-上面的例子通过适配器，把一个MicroUsb型号的充电器用来给Iphone充电。从代码层面，就是通过适配器复用了MicroUsb接口及其实现类。在很大程度上福永了已有的代码。
+上面的例子通过适配器，把一个MicroUsb型号的充电器用来给Iphone充电。从代码层面，就是通过适配器复用了MicroUsb接口及其实现类。在很大程度上复用了已有的代码。
 
 ## 优缺点
 
diff --git a/docs/advance/design-patterns/strategy-pattern.md b/docs/advance/design-patterns/strategy-pattern.md
@@ -88,7 +88,7 @@
     
         @Override
         public double calPrice(double bookPrice) {
-            System.out.println("对于中级会员的折扣为20%");
+            System.out.println("对于高级会员的折扣为20%");
             return bookPrice * 0.8;
         }
     }
@@ -149,7 +149,7 @@
         }
     }
     
-    //对于中级会员的折扣为20%
+    //对于高级会员的折扣为20%
     //高级会员图书的最终价格为：240.0
     //对于中级会员的折扣为10%
     //中级会员图书的最终价格为：270.0
diff --git a/docs/basics/concurrent-coding/concurrent.md b/docs/basics/concurrent-coding/concurrent.md
@@ -1,6 +1,6 @@
 并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。
 
-那么，操作系统视如何实现这种并发的呢？
+那么，操作系统是如何实现这种并发的呢？
 
 现在我们用到操作系统，无论是Windows、Linux还是MacOS等其实都是**多用户多任务分时操作系统**。使用这些操作系统的用户是可以“同时”干多件事的。
 
diff --git a/docs/basics/concurrent-coding/debug-in-multithread.md b/docs/basics/concurrent-coding/debug-in-multithread.md
@@ -2,7 +2,7 @@
 
 但是我之前面试过很多人，很多人都知道多线程怎么实现，但是却不知道如何调试多线程的代码，这篇文章我们来介绍下如何调试多线程的代码。
 
-首先我们写一个多线程的例子，使用继承Runnable接口的方式定义多个线程，并启动执行。
+首先我们写一个多线程的例子，使用实现Runnable接口的方式定义多个线程，并启动执行。
 
     /**
      * @author Hollis
diff --git a/docs/basics/java-basic/enum-class.md b/docs/basics/java-basic/enum-class.md
@@ -11,4 +11,4 @@ Java中定义枚举是使用enum关键字的，但是Java中其实还有一个ja
     
 这个类我们在日常开发中不会用到，但是其实我们使用enum定义的枚举，其实现方式就是通过继承Enum类实现的。
 
-当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。
+当我们使用enum来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。
diff --git a/docs/basics/java-basic/enum-singleton.md b/docs/basics/java-basic/enum-singleton.md
@@ -39,14 +39,14 @@
         private volatile static Singleton singleton;  
         private Singleton (){}  
         public static Singleton getSingleton() {  
-        if (singleton == null) {  
-            synchronized (Singleton.class) {  
             if (singleton == null) {  
-                singleton = new Singleton();  
+                synchronized (Singleton.class) {  
+                    if (singleton == null) {  
+                        singleton = new Singleton();  
+                    }  
+                }  
             }  
-            }  
-        }  
-        return singleton;  
+            return singleton;  
         }  
     }  
     
diff --git a/docs/basics/java-basic/final-string.md b/docs/basics/java-basic/final-string.md
@@ -70,7 +70,7 @@ String s2 = s;
 
 当我们在程序中传递一个字符串的时候，如果这个字符串的内容是不可变的，那么我们就可以相信这个字符串中的内容。
 
-但是，如果是可变的，那么这个字符串内容就可能随时都被修改。那么这个字符串内容就完全可信了。这样整个系统就没有安全性可言了。
+但是，如果是可变的，那么这个字符串内容就可能随时都被修改。那么这个字符串内容就完全不可信了。这样整个系统就没有安全性可言了。
 
 #### 线程安全
 
diff --git a/docs/basics/java-basic/hash-in-hashmap.md b/docs/basics/java-basic/hash-in-hashmap.md
@@ -79,7 +79,7 @@
     }
     
 
-前面我说过，`indexFor`方法其实主要是将hash生成的整型转换成链表数组中的下标。那么`return h & (length-1);`是什么意思呢？其实，他就是取模。Java之所有使用位运算(&)来代替取模运算(%)，最主要的考虑就是效率。**位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。**
+前面我说过，`indexFor`方法其实主要是将hash生成的整型转换成链表数组中的下标。那么`return h & (length-1);`是什么意思呢？其实，他就是取模。Java之所以使用位运算(&)来代替取模运算(%)，最主要的考虑就是效率。**位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。**
 
 那么，为什么可以使用位运算(&)来实现取模运算(%)呢？这实现的原理如下：
 
diff --git a/docs/basics/java-basic/hashmap-default-capacity.md b/docs/basics/java-basic/hashmap-default-capacity.md
@@ -194,7 +194,7 @@ Step 1 怎么理解呢？其实是对一个二进制数依次向右移位，然
 
 ### 扩容
 
-除了初始化的时候回指定HashMap的容量，在进行扩容的时候，其容量也可能会改变。
+除了初始化的时候会指定HashMap的容量，在进行扩容的时候，其容量也可能会改变。
 
 HashMap有扩容机制，就是当达到扩容条件时会进行扩容。HashMap的扩容条件就是当HashMap中的元素个数（size）超过临界值（threshold）时就会自动扩容。
 
diff --git a/docs/basics/java-basic/length-of-string.md b/docs/basics/java-basic/length-of-string.md
@@ -134,4 +134,4 @@ int 是一个 32 位变量类型，取正数部分来算的话，他们最长可
 
 在运行期，长度不能超过Int的范围，否则会抛异常。
 
-最后，这个知识点 ，我录制了视频(https://www.bilibili.com/video/BV1uK4y1t7H1/)，其中有关于如何进行实验测试、如何查阅Java规范以及如何对javac进行deubg的技巧。欢迎进一步学习。
+最后，这个知识点 ，我录制了视频([点击跳转](https://www.bilibili.com/video/BV1uK4y1t7H1/)) ，其中有关于如何进行实验测试、如何查阅Java规范以及如何对javac进行deubg的技巧。欢迎进一步学习。
diff --git a/docs/basics/object-oriented/java-pass-by.md b/docs/basics/object-oriented/java-pass-by.md
@@ -56,7 +56,7 @@
 
 *   传值调用（值传递） 
     *   在传值调用中，实际参数先被求值，然后其值通过复制，被传递给被调函数的形式参数。因为形式参数拿到的只是一个"局部拷贝"，所以如果在被调函数中改变了形式参数的值，并不会改变实际参数的值。
-*   传引用调用（应用传递） 
+*   传引用调用（引用传递） 
     *   在传引用调用中，传递给函数的是它的实际参数的隐式引用而不是实参的拷贝。因为传递的是引用，所以，如果在被调函数中改变了形式参数的值，改变对于调用者来说是可见的。
 *   传共享对象调用（共享对象传递） 
     *   传共享对象调用中，先获取到实际参数的地址，然后将其复制，并把该地址的拷贝传递给被调函数的形式参数。因为参数的地址都指向同一个对象，所以我们称也之为"传共享对象"，所以，如果在被调函数中改变了形式参数的值，调用者是可以看到这种变化的。

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@`
`36`	`36`	`>`
`37`	`37`	`> Product(具体产品)：定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。`
`38`	`38`
`39`		`-本文的例子采用一个汽车代工厂造汽车的例子。假设我们是一家汽车代工厂商，我们负责给奔驰和特斯拉两家公司制造车子。我们简单的把奔驰车理解为需要加油的车，特斯拉为需要充电的车。其中奔驰车中包含跑车和商务车两种，特斯拉同样也包含奔驰车和商务车。`
	`39`	`+本文的例子采用一个汽车代工厂造汽车的例子。假设我们是一家汽车代工厂商，我们负责给奔驰和特斯拉两家公司制造车子。我们简单的把奔驰车理解为需要加油的车，特斯拉为需要充电的车。其中奔驰车中包含跑车和商务车两种，特斯拉同样也包含跑车和商务车。`
`40`	`40`
`41`	`41`	`[<img src="http://www.hollischuang.com/wp-content/uploads/2016/04/QQ20160419-1.png" alt="QQ20160419-1" width="657" height="554" class="alignnone size-full wp-image-1422" />][6]`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@`
`88`	`88`
`89`	`89`	`@Override`
`90`	`90`	`public double calPrice(double bookPrice) {`
`91`		`- System.out.println("对于中级会员的折扣为20%");`
	`91`	`+ System.out.println("对于高级会员的折扣为20%");`
`92`	`92`	`return bookPrice * 0.8;`
`93`	`93`	`}`
`94`	`94`	`}`
`@@ -149,7 +149,7 @@`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`- //对于中级会员的折扣为20%`
	`152`	`+ //对于高级会员的折扣为20%`
`153`	`153`	`//高级会员图书的最终价格为：240.0`
`154`	`154`	`//对于中级会员的折扣为10%`
`155`	`155`	`//中级会员图书的最终价格为：270.0`
Original file line number	Diff line number	Diff line change
`@@ -11,4 +11,4 @@ Java中定义枚举是使用enum关键字的，但是Java中其实还有一个ja`
`11`	`11`
`12`	`12`	`这个类我们在日常开发中不会用到，但是其实我们使用enum定义的枚举，其实现方式就是通过继承Enum类实现的。`
`13`	`13`
`14`		`-当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。`
	`14`	`+当我们使用enum来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@`
`79`	`79`	`}`
`80`	`80`
`81`	`81`
`82`		-前面我说过，`indexFor`方法其实主要是将hash生成的整型转换成链表数组中的下标。那么`return h & (length-1);`是什么意思呢？其实，他就是取模。Java之所有使用位运算(&)来代替取模运算(%)，最主要的考虑就是效率。位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。
	`82`	+前面我说过，`indexFor`方法其实主要是将hash生成的整型转换成链表数组中的下标。那么`return h & (length-1);`是什么意思呢？其实，他就是取模。Java之所以使用位运算(&)来代替取模运算(%)，最主要的考虑就是效率。位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。
`83`	`83`
`84`	`84`	`那么，为什么可以使用位运算(&)来实现取模运算(%)呢？这实现的原理如下：`
`85`	`85`