update kotlin parts

CharonChui · CharonChui · commit 3b38b257aadc · 2018-03-22T20:21:13.000+08:00
diff --git a/JavaKnowledge/Java基础面试题.md b/JavaKnowledge/Java基础面试题.md
@@ -26,7 +26,7 @@ Java基础面试题
 	```
 	另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
 	```java
-	int arr[][] = {{1,2,3},{4,5,6,7},{9}};
+	int arr[][] = ...;
 	boolean found = false;
 	for(int i=0;i<arr.length && !found;i++) {
 			for(int j=0;j<arr[i].length;j++) {
diff --git a/KotlinCourse/Kotlin学习教程(一).md b/KotlinCourse/Kotlin学习教程(一).md
@@ -5,12 +5,13 @@ Kotlin学习教程(一)
 
 在`5月18`日谷歌在`I/O`开发者大会上宣布，将`Kotlin`语言作为安卓开发的一级编程语言。并且会在`Android Studio 3.0`版本全面支持`Kotlin`。   
 
-- `Kotlin`是一个基于`JVM`的新的编程语言，由`JetBrains`开发。`JetBrains`作为目前广受欢迎的`Java IDE IntelliJ`的提供商，在`Apache`许可下已经开源其`Kotlin`编程语言。     
+- `Kotlin`是一个基于`JVM`的新的编程语言，由[JetBrains](https://www.jetbrains.com/)开发。`JetBrains`作为目前广受欢迎的`Java IDE IntelliJ`的提供商，在`Apache`许可下已经开源其`Kotlin`编程语言。     
 - `Kotlin`可以编译成`Java`字节码，也可以编译成`JavaScript`，方便在没有`JVM`的设备上运行。      
 - `Kotlin`已正式成为`Android`官方开发语言。
 
 [Kotlin官网](https://kotlinlang.org/)
 
+`JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    
 
 很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云的一句话: 
 > 拥抱变化
@@ -28,6 +29,23 @@ Kotlin学习教程(一)
 - `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
 
 
+### `Kotlin`优势 
+
+- 全面支持`Lambda`表达式
+- 数据类`Data classes`
+- 函数字面量和内联函数`Function literals & inline functions`
+- 函数扩展`Extension functions`
+- 空安全`Null safety`
+- 智能转换`Smart casts`
+- 字符串模板`String templates`
+- 主构造函数`Primary constructors`
+- 类委托`Class delegation`
+- 类型推判`Type inference`
+- 单例`Singletons`
+- 声明点变量`Declaration-site variance`
+- 区间表达式`Range expressions`
+
+
 上面说简洁简洁，到底简洁在哪里？这里先用一个例子开始，在`Java`开发过程中经常会写一些`Bean`类:  
 ```java
 package com.charon.kotlinstudydemo;
@@ -110,7 +128,7 @@ import android.os.Bundle
 // 定义类，继承AppCompatActivity
 class MainActivity : AppCompatActivity() {
 	
-	// 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null
+	// 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null，如果有了?那在调用该方法的时候参数可以传递null进入，如果没有?传递null就会报错
     override fun onCreate(savedInstanceState: Bundle?) {
     	// super 
         super.onCreate(savedInstanceState)
@@ -145,43 +163,44 @@ var weight = 70.5 // double
 ```
 
 在`Kotlin`中，一切都是对象。没有像`Java`中那样的原始基本类型。
-当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似的，但是有一些不同之处你可能需要考虑到:   
+当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似的，但是有一些不同之处你可能需要考虑到:    
 
 - 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:   
 
-```kotlin
-private var age = 18
-private var weight = age.toFloat()
-```
-- 字符（`Char`）不能直接作为一个数字来处理。在需要时我们需要把他们转换为一个数字:
-```kotlin
-val c: Char='c'
-val i: Int = c.toInt()
-```
-- 位运算也有一点不同。在`Android`中，我们经常在`flags`中使用`或`: 
-
-```java
-// Java
-int bitwiseOr = FLAG1 | FLAG2;
-int bitwiseAnd = FLAG1 & FLAG2;
-```
-
-```kotlin
-// Kotlin
-val bitwiseOr = FLAG1 or FLAG2
-val bitwiseAnd = FLAG1 and FLAG2
-```
-
-- 一个`String`可以像数组那样访问，并且被迭代：
-```kotlin
-var s = "charon"
-var c = s[2]
-
-for (a in s) {
-    Log.e("@@@", a +"");
-}
-
-```
+	```kotlin
+	private var age = 18
+	private var weight = age.toFloat()
+	```
+- 字符（`Char`）不能直接作为一个数字来处理。在需要时我们需要把他们转换为一个数字:       
+
+	```kotlin
+	val c: Char='c'
+	val i: Int = c.toInt()
+	```
+- 位运算也有一点不同。在`Android`中，我们经常在`flags`中使用`或`:      
+
+	```java
+	// Java
+	int bitwiseOr = FLAG1 | FLAG2;
+	int bitwiseAnd = FLAG1 & FLAG2;
+	```
+
+	```kotlin
+	// Kotlin
+	val bitwiseOr = FLAG1 or FLAG2
+	val bitwiseAnd = FLAG1 and FLAG2
+	```
+
+- 一个`String`可以像数组那样访问，并且被迭代:     
+
+	```kotlin
+	var s = "charon"
+	var c = s[2]
+
+	for (a in s) {
+	    Log.e("@@@", a +"");
+	}
+	```
 
 
 ##### 编译期常量
diff --git a/KotlinCourse/Kotlin学习教程(五).md b/KotlinCourse/Kotlin学习教程(五).md
@@ -99,11 +99,28 @@ outter.Inner().execute()
 匿名内部类
 
 ```kotlin
+// 通过对象表达式来 创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
 text.setOnClickListener(object : View.OnClickListener{
     override fun onClick(p0: View?) {
         Log.d("test", p0.string())
     }
 })
+
+或
+mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
+    override fun onPageScrollStateChanged(state: Int) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun onPageSelected(position: Int) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+})
 ```
 
 
@@ -172,6 +189,17 @@ val s = when(x){
 val s = try { x as String } catch(e: ClassCastException) { null }
 ```
 
+### 对象`(Object)`
+
+声明对象就如同声明一个雷，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。    
+事实上，对象就是具有单一实现的数据类型。
+
+```kotlin
+object Resource {
+    val name = "Name"
+}
+```
+
 ### 单例
 
 ```kotlin
@@ -180,6 +208,50 @@ object Resource {
 }
 ```
 
+因为对象就是具有单一实现的数据类型，所以在`kotlin`中对象就是单例。   
+对象的实例在我们第一次使用时，被创建。所以这里有一个懒惰实例化:如果一个对象永远不会被使用，这个实例永远不会被创建。
+
+### 对象表达式
+
+对象也能用于创建匿名类实现。
+
+```java
+recycler.adapter = object : RecyclerView.Adapter() {
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder?, position: Int) {
+    }
+ 
+    override fun getItemCount(): Int {
+    }
+ 
+    override fun onCreateViewHolder(parent: ViewGroup?, viewType: Int): RecyclerView.ViewHolder {
+    }
+}
+```
+例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
+
+
+### 伴生对象`(Companion Object)`
+
+每个类都可以实现一个伴生对象，它是该类的所有实例共有的对象。它将类似于`Java`中的静态字段。
+```java
+class App : Application() {
+    companion object {
+         lateinit var instance: App
+             private set
+     }
+ 
+     override fun onCreate() {
+         super.onCreate()
+         instance = this
+    }
+}
+```
+
+在这例子中，创建一个由`Application`扩展的（派送）的类，并且在`companion object`中存储它的唯一实例。     
+`lateinit`表示这个属性开始是没有值得，但是，在使用前将被赋值（否则，就会抛出异常）。     
+`private set`用于说明外部类不能对其进行赋值。   
+
+
 ### 委托(代理)
 
 ##### 类委托
@@ -215,8 +287,7 @@ BaseImpl -> 5
 
 ##### 属性委托
 
-语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`和`setValue()`方法。 属性的委托不必实现任何的接口，但是需要提供一个`getValue()`函数（和`setValue()`——对于`var属性）。
-
+语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`和`setValue()`方法。 属性的委托不必实现任何的接口，但是需要提供一个`getValue()`函数（和`setValue()`——对于`var`属性）。
 
 ```kotlin
 class Example {
diff --git a/KotlinCourse/Kotlin学习教程(四).md b/KotlinCourse/Kotlin学习教程(四).md
@@ -1,4 +1,4 @@
-Kotlin学习教程(三)
+Kotlin学习教程(四)
 ===
 
 
@@ -282,6 +282,26 @@ studentArray[0] = Student("james")
 `Kotlin`没有专门的语法结构创建`list`或`set`。要用标准库的方法如`listOf()`、`mutableListOf()`、`setOf()`、`mutableSetOf()`。创建`map`可以用`mapOf(a to b, c to d)`。
 
 ```kotlin
+fun main(args : Array<String>) {
+    var lists = listOf("a", "b", "c")
+    for(list in lists) {
+        println(list)
+    }
+}
+```
+
+```kotlin
+fun main(args : Array<String>) {
+    var map = TreeMap<String, String>()
+    map["0"] = "0 haha"
+    map["1"] = "1 haha"
+    map["2"] = "2 haha"
+    
+    println(map["1"])
+}
+```
+
+```kotlin    
 val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
 val readOnlyView: List<Int> = numbers
 println(numbers)        // 输出 "[1, 2, 3]"
@@ -311,7 +331,7 @@ value2 = null       // 编译能通过
 ```kotlin
 var str : String? = null
 str.length    // 编译不错误
-str?.length   // 编译能通过
+str?.length   // 编译能通过，这表示如果str不为空的时候执行length方法
 ```
 
 那么问题来了，我们知道在`java`中`String.length`返回的是`int`，上面的`str?.length`既然编译通过了，那么它返回了什么？我们可以这么写:  
@@ -449,7 +469,15 @@ loop@ for (i in 1..100) {
 
 ### Ranges
 
-`Range`表达式使用一个`..`操作符。
+`Range`表达式使用一个`..`操作符。表示就是一个该范围内的数据的数组，包含头和尾
+
+```kotlin
+var nums = 1..100 
+for(num in nums) {
+	println(num)
+	// 打印出1 2 3 ....100
+}
+```
 
 ```kotlin
 if(i >= 0 && i <= 10) 
@@ -458,7 +486,7 @@ if(i >= 0 && i <= 10)
 转换成 
 
 ```kotlin
-if (i in 0..10)
+if (i in 0..10) 
     println(i)
 ```
 Ranges默认会自增长，所以如果像以下的代码：
@@ -478,6 +506,18 @@ for (i in 1..4 step 2) println(i)
 for (i in 4 downTo 1 step 2) println(i)
 ```
 
+### Until
+
+上面的`Range`是包含了头和尾，那如果只想包含头不包含尾呢？ 就要用`until`
+
+```kotlin
+var nums = 1 until 100
+for(num in nums) {
+	println(num)
+	// 这样打印出来是1 2 3 .....99
+}
+```
+
 
 ---
 
