image

背景

近幾年，Android 相關的新技術層出不窮。往往這個技術還沒學完，下一個新技術又出來了。很多人都是一臉黑人問號？不少開發(fā)者甚至開始哀嚎：“求求你們別再創(chuàng)造新技術了，我們學不動了！”

在這些新技術里，Kotlin，協(xié)程，Jetpack 是最具代表性的，它們的知識體系復雜，學起來難度大，學完后實戰(zhàn)的坑也多。本系列文章原本是我為小組新人培訓準備的，現(xiàn)在重新整理分享出來。

簡介

本文主要講解 Kotlin 基礎語法。

本文是《Kotlin Jetpack 實戰(zhàn)》的開篇。

每個 Java 開發(fā)者都應該學 Kotlin

推薦學習 Kotlin 的理由有很多，比如：Kotlin 更簡潔，Kotlin 有協(xié)程，Kotlin 有擴展函數(shù)，學了 Kotlin 后學別的語言會很快，比如：Python，Swift，Dart, Ruby...

不過，如果你是 Android 開發(fā)者，我勸你別再做無謂的掙扎了，趕緊入坑吧！

1. 快速認識 Kotlin

Kotlin 是著名 IDE 公司 JetBrains 創(chuàng)造出的一門基于 JVM 的語言。Kotlin 有著以下幾個特點：

• 簡潔，1行頂5行
• 安全，主要指“空安全”
• 兼容，與 Java 兼容
• 工具友好，IntelliJ 對 Kotlin 簡直不要太友好

JetBrains 不僅創(chuàng)造了 Kotlin，還創(chuàng)造了著名的 IntelliJ IDEA。Android 開發(fā)者使用的 Android Studio 就是基于 IntelliJ 改造出來的。

2. 所有 Kotlin 類都是對象 (Everything in Kotlin is an object)

與 Java 不一樣是：Kotlin 沒有基本數(shù)據類型 (Primitive Types)，所有 Kotlin 里面的類都是對象，它們都繼承自: Any這個類；與 Java 類似的是，Kotlin 提供了如下的內置類型：

思考題1：

既然 Kotlin 與 Java 是兼容的，那么 Kotlin Int 與 Java int、Java Integer 之間是什么關系？

思考題2：

Kotlin Any 類型與 Java Object 類型之間有什么關系？

3. 可見性修飾符 (Visibility Modifiers)

4. 變量定義 (Defining Variables)

定義一個 Int 類型的變量:

var a: Int = 1

定義一個 Int 類型的常量(不可變的變量？只讀的變量？)

val b: Int = 1

類型可推導時，類型申明可省略:

val c = 1

語句末尾的;可有可無:

val d: Int;
d = 1;

小結：

• var 定義變量
• val 定義常量(不可變的變量？只讀變量？)
• Kotlin 支持類型自動推導

思考題3：

Kotlin val 變量與 Java 的 final 有什么關系？

5. 空安全 (Null Safety)

定義一個可為空的 String 變量:

var b: String? = "Kotlin"
b = null
print(b)
// 輸出 null

定義一個不可為空的 String 變量:

var a: String = "Kotlin"
a = null
// 編譯器報錯，null 不能被賦給不為空的變量

變量賦值：

var a: String? = "Kotlin"
var b: String = "Kotlin"
b = a // 編譯報錯，String? 類型不可以賦值給 String 類型

a = b // 編譯通過

空安全調用

var a: String? = "Kotlin"
print(a.length) // 編譯器報錯，因為 a 是可為空的類型
print(a?.length) // 使用?. 的方式調用，輸出 null

Elvis 操作符

// 下面兩個語句等價
val l: Int = if (b != null) b.length else -1
val l = b?.length ?: -1

// Elvis 操作符在嵌套屬性訪問時很有用
val name = userInstance?.user?.baseInfo?.profile?.name?: "Kotlin"

小結：

• T 代表不可為空類型，編譯器會檢查，保證不會被 null 賦值
• T? 代表可能為空類型
• 不能將 T? 賦值給 T
• 使用 instance?.fun() 進行空安全調用
• 使用 Elvis 操作符為可空變量替代值，簡化邏輯

6. 類型檢查與轉換 (Type Checks and Casts)

類型判斷、智能類型轉換：

if (x is String) {
    print(x.length) // x 被編譯自動轉換為 String
}
// x is String 類似 Java 里的 instanceOf

不安全的類型轉換 as

val y = null
val x: String = y as String
//拋異常，null 不能被轉換成 String

安全的類型轉換 as?

val y = null
val z: String? = y as? String
print(z)
// 輸出 null

小結：

• 使用 is 關鍵字進行類型判斷
• 使用 as 進行類型轉換，可能會拋異常
• 使用 as? 進行安全的類型轉換

7. if 判斷

基礎用法跟 Java 一毛一樣。它們主要區(qū)別在于：Java If is Statement，Kotlin If is Expression。因此它對比 Java 多了些“高級”用法，懶得講了，咱看后面的實戰(zhàn)吧。

8. for 循環(huán)

跟 Java 也差不多，隨便看代碼吧：

// 集合遍歷，跟 Java 差不多
for (item in collection) {
    print(item)
}

// 辣雞 Kotlin 語法
for (item in collection) print(item)

// 循環(huán) 1，2，3
for (i in 1..3) {
    println(i)
}

// 6，4，2，0
for (i in 6 downTo 0 step 2) {
    println(i)
}

9. when

when 就相當于高級版的 switch，它的高級之處在于支持模式匹配(Pattern Matching):

val x = 9
when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    is String -> print("x is String")
    x.isOdd() -> print("x is odd")
    else -> print("none of the above")
}
// 輸出：x is in the range

10. 相等性 (Equality)

Kotlin 有兩種類型的相等性：

• 結構相等 (Structural Equality)
• 引用相等 (Referential Equality)

結構相等：

// 下面兩句兩個語句等價
a == b
a?.equals(b) ?: (b === null)
// 如果 a 不等于 null，則通過 equals 判斷 a、b 的結構是否相等
// 如果 a 等于 null，則判斷 b 是不是也等于 null

引用相等：

print(a === b)
// 判斷 a、b 是不是同一個對象

思考題4：

val a: Int = 10000
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA)
print(boxedA === anotherBoxedA)
// 輸出什么內容?

思考題5：

val a: Int = 1
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA)
print(boxedA === anotherBoxedA)
// 輸出什么內容?

11. 函數(shù) (Functions)

fun triple(x: Int): Int {
    return 3 * x
}
// 函數(shù)名：triple
// 傳入參數(shù)：不為空的 Int 類型變量
// 返回值：不為空的 Int 類型變量

12. 類 (Classes)

類定義

使用主構造器(Primary Constructor)定義類一個 Person 類，需要一個 String 類型的變量：

class Person constructor(firstName: String) { ... }

如果主構造函數(shù)沒有注解或者可見性修飾符，constructor 關鍵字可省略:

class Person(firstName: String) { ... }

也可以使用次構造函數(shù)(Secondary Constructor)定義類：

class Person {
    constructor(name: String) { ... }
}

// 創(chuàng)建 person 對象
val instance = Person("Kotlin")

init 代碼塊

Kotlin 為我們提供了 init 代碼塊，用于放置初始化代碼：

class Person {
    var name = "Kotlin"
    init {
        name = "I am Kotlin."
        println(name)
    }

    constructor(s: String) {
        println(“Constructor”)
    }
}

fun main(args: Array<String>) {
    Person("Kotlin")
}

以上代碼輸出結果為：

I am Kotlin.
Constructor

結論：init 代碼塊執(zhí)行時機在類構造之后，但又在“次構造器”執(zhí)行之前。

13. 繼承 (Inheritance)

• 使用 open 關鍵字修飾的類，可以被繼承
• 使用 open 關鍵字修飾的方法，可以被重寫
• 沒有 open 關鍵字修飾的類，不可被繼承
• 沒有 open 關鍵字修飾的方法，不可被重寫
• 以 Java 的思想來理解，Kotlin 的類和方法，默認情況下是 final 的

定義一個可被繼承的 Base 類，其中的 add() 方法可以被重寫，test() 方法不可被重寫：

open class Base {
    open fun add() { ... }
    fun test() { ... }
}

定義 Foo 繼承 Base 類，重寫 add() 方法

class Foo() : Base() {
    override fun add() { ... }
}

• 使用 : 符號來表示繼承
• 使用 override 重寫方法

14. This 表達式 (Expression)

class A {

    fun testA(){    }

    inner class B { // 在 class A 定義內部類 B

        fun testB(){    }

        fun foo() {
            this.testB() // ok
            this.testA() // 編譯錯誤
            this@A.testA() // ok
            this@B.testB() // ok
        }
    }
}

小結：

• inner 關鍵字定義內部類
• 在內部類當中訪問外部類，需要顯示使用 this@OutterClass.fun() 的語法

15. 數(shù)據類 (Data Class)

假設我們有個這樣一個 Java Bean:

public class Developer {
        private String name;

        public Developer(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Developer developer = (Developer) o;
            return name != null ? name.equals(developer.name) : developer.name == null;
        }

        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            return result;
        }

        @Override
        public String toString() {
            return "Developer{" + "name='" + name + '}';
        }
    }

如果我們將其翻譯成 Kotlin 代碼，大約會是這樣的:

class Developer(var name: String?) {

    override fun equals(o: Any?): Boolean {
        if (this === o) return true
        if (o == null || javaClass != o.javaClass) return false
        val developer = o as Developer?
        return if (name != null) name == developer!!.name else developer!!.name == null
    }

    override fun hashCode(): Int {
        return if (name != null) name!!.hashCode() else 0
    }

    override fun toString(): String {
        return "Developer{" + "name='" + name + '}'.toString()
    }
}

然而，Kotlin 為我們提供了另外一種選擇，它叫做數(shù)據類:

data class Developer(var name: String)

上面這一行簡單的代碼，完全能替代前面我們的寫的那一大堆模板 Java 代碼，甚至額外多出了一些功能。如果將上面的數(shù)據類翻譯成等價的 Java 代碼，大概會長這個樣子：

public final class Developer {
   @NotNull
   private String name;

   public Developer(@NotNull String name) {
      super();
      this.name = name;
   }

   @NotNull
   public final String getName() {   return this.name;   }

   public final void setName(@NotNull String var1) {    this.name = var1;   }

   @NotNull
   public final Developer copy(@NotNull String name) {   return new Developer(name);   }

   public String toString() {   return "Developer(name=" + this.name + ")";   }

   public int hashCode() {   return this.name != null ? this.name.hashCode() : 0;   }

   public boolean equals(Object var1) {
      if (this != var1) {
         if (var1 instanceof Developer) {
            Developer var2 = (Developer)var1;
            if (Intrinsics.areEqual(this.name, var2.name)) {
               return true;
            }
         }
         return false;
      } else {
         return true;
      }
   }
}

可以看到，Kotlin 的數(shù)據類不僅為我們提供了 getter、setter、equals、hashCode、toString，還額外的幫我們實現(xiàn)了 copy 方法！這也體現(xiàn)了 Kotlin 的簡潔特性。

序列化的坑

如果是舊工程遷移到 Kotlin，那么可能需要注意這個坑:

// 定義一個數(shù)據類，其中成員變量 name 是不可為空的 String 類型，默認值是 Android
data class Person(val age: Int, val name: String = "Kotlin")
val person = gson.fromJson("""{"age":42}""", Person::class.java)
print(person.name) // 輸出 null

對于上面的情況，由于 Gson 最初是為 Java 語言設計的序列化框架，并不支持 Kotlin 不可為空、默認值這些特性，從而導致原本不可為空的屬性變成null，原本應該有默認值的變量沒有默認值。

對于這種情，市面上已經有了解決方案:

• kotlinx.serialization
• moshi

16. 擴展 (Extensions)

如何才能在不修改源碼的情況下給一個類新增一個方法？比如我想給 Context 類增加一個 toast 類，怎么做？

如果使用 Java，上面的需求是無法被滿足的。然而 Kotlin 為我們提供了擴展語法，讓我們可以輕松實現(xiàn)以上的需求。

擴展函數(shù)

為 Context 類定義一個 toast 方法：

fun Context.toast(msg: String, length: Int = Toast.LENGTH_SHORT){
    Toast.makeText(this, msg, length).show()
}

擴展函數(shù)的使用：

val activity: Context? = getActivity()
activity?.toast("Hello world!")
activity?.toast("Hello world!", Toast.LENGTH_LONG)

屬性擴展

除了擴展函數(shù)，Kotlin 還支持擴展屬性，用法基本一致。

思考題6：

上面的例子中，我們給不可為空的 Context 類增加了擴展函數(shù)，因此我們在使用這個方法的時候需要判斷。實際上，Kotlin 還支持我們?yōu)?可為空的 類增加擴展函數(shù)：

// 為 Context? 添加擴展函數(shù)
fun Context?.toast(msg: String, length: Int = Toast.LENGTH_SHORT){
    if (this == null) {    //do something    }
    Toast.makeText(this, msg, length).show()
}

擴展函數(shù)使用：

val activity: Context? = getActivity()
activity.toast("Hello world!")
activity.toast("Hello world!", Toast.LENGTH_LONG)

請問這兩種定義擴展函數(shù)的方式，哪種更好？分別適用于什么情景？為什么？

17. 委托 (Delegation)

Kotlin 中，使用by關鍵字表示委托：

interface Animal {
    fun bark()
}

// 定義 Cat 類，實現(xiàn) Animal 接口
class Cat : Animal {
    override fun bark() {
        println("喵喵")
    }
}

// 將 Zoo 委托給它的參數(shù) animal
class Zoo(animal: Animal) : Animal by animal

fun main(args: Array<String>) {
    val cat = Cat()
    Zoo(cat).bark()
}
// 輸出結果：喵喵

屬性委托 (Property Delegation)

其實，從上面類委托的例子中，我們就能知道，Kotlin 之所以提供委托這個語法，主要是為了方便我們使用者，讓我們可以很方便的實現(xiàn)代理這樣的模式。這一點在 Kotlin 的委托屬性這一特性上體現(xiàn)得更是淋漓盡致。

Kotlin 為我們提供的標準委托非常有用。

by lazy 實現(xiàn)”懶加載“

// 通過 by 關鍵字，將 lazyValue 屬性委托給 lazy {} 里面的實現(xiàn)
val lazyValue: String by lazy {
    val result = compute()
    println("computed!")
    result
}

// 模擬計算返回的變量
fun compute():String{
    return "Hello"
}

fun main(args: Array<String>) {
    println(lazyValue)
    println("=======")
    println(lazyValue)
}

以上代碼輸出的結果：

computed!
Hello
=======
Hello

由此可見，by lazy 這種委托的方式，可以讓我們輕松實現(xiàn)懶加載。
其內部實現(xiàn)，大致是這樣的：

by lazy 執(zhí)行流程

lazy 求值的線程模式: LazyThreadSafetyMode

Kotlin 為lazy 委托提供三種線程模式，他們分別是：

• LazyThreadSafetyMode.SYNCHRONIZED
• LazyThreadSafetyMode.NONE
• LazyThreadSafetyMode.PUBLICATION

上面這三種模式，前面兩種很好理解：

1. LazyThreadSafetyMode.SYNCHRONIZED 通過加鎖實現(xiàn)多線程同步，這也是默認的模式。
2. LazyThreadSafetyMode.NONE 則沒有任何線程安全代碼，線程不安全。

我們詳細看看LazyThreadSafetyMode.PUBLICATION，官方文檔的解釋是這樣的：

Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value, but only the first returned value will be used as the value of [Lazy] instance.

意思就是，用LazyThreadSafetyMode.PUBLICATION模式的 lazy 委托變量，它的初始化方法是可能會被多個線程執(zhí)行多次的，但最后這個變量的取值是僅以第一次算出的值為準的。即，哪個線程最先算出這個值，就以這個值為準。

by Delegates.observable 實現(xiàn)"觀察者模式"的變量

觀察者模式，又被稱為訂閱模式。最常見的場景就是：比如讀者們訂閱了Android公眾號，每次Android更新的時候，讀者們就會收到推送。而觀察者模式應用到變量層面，就延伸成了：如果這個的值改變了，就通知我。

class User {
    // 為 name 這個變量添加觀察者，每次 name 改變的時候，都會執(zhí)行括號內的代碼
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("name 改變了：$old -> $new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "first: Tom"
    user.name = "second: Jack"
}

以上代碼的輸出為：

name 改變了：<no name> -> first: Tom
name 改變了：first: Tom -> second: Jack

思考題7：

lazy 委托的LazyThreadSafetyMode.PUBLICATION適用于什么樣的場景？

結尾

都看到這了，點個贊唄！