update

CharonChui · CharonChui · commit 90d08d8e0b80 · 2021-06-28T15:27:12.000+08:00
diff --git a/KotlinCourse/1.Kotlin_简介&变量&类&接口.md b/KotlinCourse/1.Kotlin_简介&变量&类&接口.md
@@ -31,7 +31,7 @@
 and first-class delegation`等实现
 - `Kotlin`可与`Java`语言无缝通信。这意味着我们可以在`Kotlin`代码中使用任何已有的`Java`库；同样的`Kotlin`代码还可以为`Java`代码所用
 - `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
-- Kotlin 是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
+- `Kotlin`是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
 
 
 ## `Kotlin`优势
@@ -195,13 +195,13 @@ var weight = 70.5 // double
 	val bitwiseAnd = FLAG1 and FLAG2
 	```
 
-- 一个`String`可以像数组那样访问，并且被迭代:     
+- 一个`String`可以像数组那样访问，并且也可以被迭代:     
 	```kotlin
 	var s = "charon"
 	var c = s[2]
 
 	for (a in s) {
-	    Log.e("@@@", a +"");
+	    Log.e("@@@", a + "");
 	}
 	```
 
@@ -263,11 +263,11 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 
-## 后端变量`Backing Fields`.
+## 后端变量`Backing Fields`
 
 `Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
 
-在`kotlin`的`getter`和`setter`是不允许本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
+在`kotlin`的`getter`和`setter`是不允许调用本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
 
 例如:    
 
@@ -319,7 +319,7 @@ var myProperty: String
 ## 延迟初始化
 
 我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
-假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
+假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），这就与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
 
 ```kotlin
 class MainActivity : AppCompatActivity() {
@@ -400,7 +400,7 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 
 ## 类的定义:使用`class`关键字
 
-当你在定义类的时候，你需要想想该类所创建的对象需要什么。你需要考虑：
+当你在定义类的时候，需要想想该类所创建的对象需要什么：
 
 - 每个对象自身的特点
 
@@ -456,7 +456,7 @@ val myDog = Dog("Fido", 70, "Mixed" )
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_dog.jpg?raw=true)        
 
-类中所定义的函数又称为成员函数。有时也被称为方法。
+类中所定义的函数又称为成员函数，有时也被称为方法。
 
 #### 创建对象的执行过程
 
@@ -587,7 +587,7 @@ class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
 Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上却是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
 
 ```kotlin
-class Bird(weight: Double, aget: Int, color: String) {
+class Bird(weight: Double, age: Int, color: String) {
     init {
         println("the weight is ${weight}")
     }
@@ -611,16 +611,14 @@ class Bird(weight: Double, aget: Int, color: String) {
     val weight: Double
     val age: Int
     val color: String
+    init {
+        this.weight = weight
+        this.age = age
+    }
+    init {
+        this.color = color
+    }
 }
-
-init {
-    this.weight = weight
-    this.age = age
-}
-init {
-    this.color = color
-}
-
 ```
 
 可以发现，多个init语句块有利于进一步对初始化的操作进行职能分离，这在复杂的业务开发中显得特别有用。
@@ -768,31 +766,7 @@ class Person // 从 Any 隐式继承
 ```
 
 `Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
-`Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
-要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
-
-```kotlin
-open class Person(num: Int)
-// 继承
-class SuperPerson(num: Int) : Person(num)
-```
-
-冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
-
-
-
-如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
-如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
-注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
-
-```kotlin
-class MyView : View {
-    constructor(ctx: Context) : super(ctx)
-    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
-}
-```
-
-在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
+`在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
 
 ```kotlin
 class Bird {
@@ -825,6 +799,27 @@ public final class Bird {
 }
 ```
 
+所以Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
+要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
+
+```kotlin
+open class Person(num: Int)
+// 继承
+class SuperPerson(num: Int) : Person(num)
+```
+
+冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
+
+如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
+注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
+
+```kotlin
+class MyView : View {
+    constructor(ctx: Context) : super(ctx)
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
 
 
 ### Any
@@ -1090,7 +1085,7 @@ fun main(args: Array<String>) {
 }
 ```
 
-从Kotlin1.3版本器，你可以忽略main函数的参数，写成如下形式:   
+从Kotlin1.3版本起，你可以忽略main函数的参数，写成如下形式:   
 
 ```kotlin
 fun main() {
@@ -1105,7 +1100,7 @@ fun main() {
 ### 可变长参数函数:使用`vararg`关键字
 
 ```kotlin
-fun vars(vararg v:Int){
+fun vars(vararg v: Int){
     for(vt in v){
         print(vt)
     }
diff --git a/KotlinCourse/2.Kotlin_高阶函数&Lambda&内联函数.md b/KotlinCourse/2.Kotlin_高阶函数&Lambda&内联函数.md
@@ -154,7 +154,7 @@ class CountryTest {
     countryApp.filterContries(countries, countryTest::isBigEuropeanCountry)
     ```
 
-经过重构后的程序显然比之前要优雅许多，程序可以根据任意的筛选需求，调用同一个filterCountries方法来获取国家数据。
+经过重构后的程序显然比之前要优雅许多，程序可以根据任意的需求筛选，调用同一个filterCountries方法来获取国家数据。
 
 #### 方法引用表达式更多使用场景
 
@@ -187,10 +187,6 @@ fun main(args: Array<String>) {
 }
 ```
 
-
-
-
-
 ## 匿名函数
 
 再来思考下上面代码中的CountryTest类，这仍算不上是一种很好的方案。因为每增加一个需求，我们都需要在类中专门写一个新增的筛选方法。然而Shaw的需求很多都是临时性的，不需要被复用。Shaw觉得这样还是比较麻烦，他打算用匿名函数对程序进一步的优化。
@@ -250,7 +246,7 @@ val foo = { x: Int ->
 
 
 > “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
-> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包（注意和数学传统意义上的不同）。
+> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包。
 
 
 
@@ -289,7 +285,7 @@ Runnable runnable2=()->{
 - 函数体(如果存在的话)在`->`后面。
 
 `Lambda`表达式是定义匿名函数的简单方法。由于`Lambda`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
-所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一个函数的参数。
+所以它是非常有用的。
 
 `Lambda`表达式由箭头左侧函数的参数（在圆括号里的内容）定义的，将值返回到箭头右侧。
 `view.setOnClickListener({ view -> toast("Click")})`
@@ -397,7 +393,7 @@ val addFive: (Int) -> Int = { x -> x + 5 }
 由于lambda具有单独的参数x，而且编译器能够推断出x为Int类型，因此我们可以省略该x参数，并在lambda的主体中使用it替换它：
 
 ```kotlin
-val addFive: (Int) - Int = { it + 5 }
+val addFive: (Int) -> Int = { it + 5 }
 ```
 
 在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
diff --git a/KotlinCourse/3.Kotlin_数字&字符串&数组&集合.md b/KotlinCourse/3.Kotlin_数字&字符串&数组&集合.md
@@ -4,8 +4,7 @@
 前面介绍了基本语法和编码规范后，接下来学习下基本类型。  
 
 在`Kotlin`中，所有东西都是对象，在这个意义上讲我们可以在任何变量上调用成员函数和属性。 一些类型可以有特殊的内部表示——例如，
-数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。 在本节中，我们会描述`Kotlin`中使用的基本类型:
-数字、字符、布尔值、数组与字符串。
+数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。
 
 ### 数字  
 
@@ -197,7 +196,8 @@ val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
 Kotlin中的判等性主要有两种类型： 
 
 - 结构相等。通过操作符==来判断两个对象的内容是否相等。
-- 引用相等。通过操作符===来判断两个对象的引用是否一样，与之相反的判断操作符是！==。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+- 引用相等。通
+引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
 
 ```kotlin
 var a = "Java"
@@ -214,13 +214,6 @@ c === f // false
 ```
 
 
-
-### 引用相等
-
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。
-
-### 结构相等
-
 结构相等由`==`以及其否定形式`!==`操作判断。按照惯例，像`a == b`这样的表达式会翻译成      
 `a?.equals(b) ?: (b === null)`
 也就是说如果`a`不是`null`则调用`equals(Any?)`函数，否则即`a`是`null`检查`b`是否与`null`引用相等。
@@ -254,14 +247,14 @@ print(boxedA == anotherBoxedA) // 输出“true”
     我们就不能在定义这个类之外的文件中使用它。
     另一方面，如果我们在一个类里面使用了private修饰符，那访问权限就被限制在这个类里面了。甚至是继承这个类的子类也不能使用它。
 
-- `protected`.    
+- `protected`    
     在Java中是包、类及子类可访问，而在Kotlin中只允许类及子类。
 
 - `internal`
     它与Java的default有点像但也有所区别。如果是一个定义为`internal`的包成员的话，对所在的整个`module`可见。如果它是一个其它领域的成员，它就需要依赖那个领域的可见性了。
     比如如果写了一个`private`类，那么它的`internal`修饰的函数的可见性就会限制与它所在的这个类的可见性。
 
-- `public`.   
+- `public`   
     你应该可以才想到，这是最没有限制的修饰符。这是默认的修饰符，成员在任何地方被修饰为public，很明显它只限制于它的领域。
 
 ### 数组
@@ -525,14 +518,14 @@ str?.length
 这么写编译器是能通过的，那么`result`的类型是什么呢？在`Kotlin`中，编译器会自动根据结果判断变量的类型，翻译成普通代码如下:   
 
 ```kotlin
-if(str == null)
-    result = null;            // 这里result为一个引用类型
-else
-    result = str.length;    // 这里result为Int
+if(str == null) {
+    result = null         // 这里result为一个引用类型
+} else {
+    result = str.length   // 这里result为Int
+}
 ```
 
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号`:`双
-感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号:双感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
 
 ```kotlin
 var str : String? = null
diff --git a/KotlinCourse/4.Kotlin_表达式&关键字.md b/KotlinCourse/4.Kotlin_表达式&关键字.md
@@ -172,8 +172,8 @@ for (i in 4 downTo 1 step 2) println(i)
 ```kotlin
 var nums = 1 until 100
 for(num in nums) {
-	println(num)
-	// 这样打印出来是1 2 3 .....99
+    println(num)
+    // 这样打印出来是1 2 3 .....99
 }
 ```
 
diff --git a/KotlinCourse/5.Kotlin_内部类&密封类&枚举&委托.md b/KotlinCourse/5.Kotlin_内部类&密封类&枚举&委托.md
diff --git a/KotlinCourse/6.Kotlin_多继承问题.md b/KotlinCourse/6.Kotlin_多继承问题.md
