前言

• Kotlin被Google官方認(rèn)為是Android開發(fā)的一級(jí)編程語言
• 今天，我將獻(xiàn)上一份 《全面 & 詳細(xì)的Kotlin入門學(xué)習(xí)指南》，包括定義特點(diǎn)、配置使用、入門語法等，希望你們會(huì)喜歡。
  
  image.png

1. 定義

• Android開發(fā)的一級(jí)編程語言（Google官方認(rèn)證）
• 由JetBrains公司在2010年推出 & 開源，與Java語言互通 & 具備多種Java尚不支持的新特性
• Android Studio3.0后的版本支持Kotlin

2. 特點(diǎn)

image.png

3. 配置使用

下面將講解如何在Android Studio配置Kotlin進(jìn)行使用。

3.1 Android Studio3.0前的版本

主要分為3個(gè)步驟，完成3個(gè)步驟即可完成Kotlin的配置。

步驟1：安裝Kotlin插件

image.png

步驟2：在根目錄的build.gradle中加入

buildscript {
    ext.kotlin_version = '1.2.10'

    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

步驟3：在app/build.gradle中引入

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'

buildscript {
    ext.kotlin_version = '1.2.10'

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

3.2 Android Studio3.0前后的版本

image.png

4. 基本語法入門

本節(jié)中，會(huì)詳細(xì)講解Kotlin的基本語法，主要包括：

• 基本觀念（對(duì)比于Java）
• 數(shù)據(jù)類型
• 類
• 變量 & 常量
• 函數(shù)
• 其他語法糖（控制流、類型檢查 & 轉(zhuǎn)換、安全性等）

4.1 基本觀念

在Kotlin中，有一些觀念是和Java存在較大區(qū)別的，一些基本觀念需要注意的：

• 操作對(duì)象：在Kotlin中，所有變量的成員方法和屬性都是對(duì)象，若無返回值則返回Unit對(duì)象，大多數(shù)情況下Uint可以省略；Kotlin 中沒有 new 關(guān)鍵字

• 數(shù)據(jù)類型 & 轉(zhuǎn)換：在Java中通過裝箱和拆箱在基本數(shù)據(jù)類型和包裝類型之間相互轉(zhuǎn)換；在Kotlin中，而不管是常量還是變量在聲明是都必須具有類型注釋或者初始化，如果在聲明 & 進(jìn)行初始化時(shí)，會(huì)自行推導(dǎo)其數(shù)據(jù)類型。

• 編譯的角度：和Java一樣，Kotlin同樣基于JVM。區(qū)別在于：后者是靜態(tài)類型語言，意味著所有變量和表達(dá)式類型在編譯時(shí)已確定。

• 撰寫：在Kotlin中，一句代碼結(jié)束后不用添加分號(hào) “；”；而在Java中，使用分號(hào)“;”標(biāo)志一句代碼結(jié)束。

4.2 數(shù)據(jù)類型

主要包括：

• 數(shù)值（Numbers）
• 字符（Characters）
• 字符串（Strings）
• 布爾（Boolean）
• 數(shù)組（Arrays）

a. 數(shù)值類型（Numbers）

image.png

注：區(qū)別于Java，在Kotlin中字符（char）不屬于數(shù)值類型，是一個(gè)獨(dú)立的數(shù)據(jù)類型。

• 補(bǔ)充說明：每種數(shù)據(jù)類型使用對(duì)應(yīng)方法，可將其他類型轉(zhuǎn)換成其他數(shù)據(jù)類型

toByte()：Byte
toShort()：Short
toInt()：Int
toLong()：Long
toFloat()： Float
toDouble()：Double
toChar()：Char

b. 字符類型（Characters）

Kotlin中的字符類型采用 Char 表示，必須使用單引號(hào)’ '包含起來使用 & 不能直接和數(shù)字操作

val ch :Char = 1; // 錯(cuò)誤示范
val ch :Char = '1'; // 正確示范

// 將字符類型轉(zhuǎn)換成數(shù)字
val ch :Char = '8';
val a :Int = ch.toInt()

c. 字符串類型（Strings）

• 表示方式：String
• 特點(diǎn)：不可變
• 使用：通過索引訪問的字符串中的字符：s [i]

// 使用1：一個(gè)字符串可以用一個(gè)for循環(huán)迭代輸出
for (c in str) {
    println(c)
}

// 使用2：可使用三個(gè)引號(hào) """拼接多行字符串
fun main(args: Array<String>) {
    val text = """
    字符串1
    字符串2
    """
    println(text)   // 輸出存在一些前置空格
}

// 注：可通過 trimMargin()刪除多余空白
fun strSample() {
    val text = """
    | str1
    |str2
    |多行字符串
    |bbbbbb
    """.trimMargin()
    println(text)    // 刪除了前置空格
}

補(bǔ)充說明：字符串模版（String Templates）

• 即在字符串內(nèi)通過一些小段代碼求值并把結(jié)果合并到字符串中。
• 模板表達(dá)式以美元符（$）開頭

// $：表示一個(gè)變量名 / 變量值
// 示例
val i = 10
val s = "i = $i" // 表示 "i = 10"

// ${varName.fun()}：表示變量的方法返回值
// 示例
val s = "abc"
val str = "$s.length is ${s.length}" //識(shí)別為 "abc.length is 3"

d. 布爾類型（Boolean）

• Kotlin的Boolean類似于Java的boolean類型，其值只有true 、false
• Boolean內(nèi)置的函數(shù)邏輯運(yùn)算包括：

|| – 短路邏輯或
&& – 短路邏輯與
! - 邏輯非

e. 數(shù)組類型（Arrays）

• 實(shí)現(xiàn)方式：使用Array類
• 使用方法：size 屬性、get方法和set 方法。注：使用 [] 重載了 get 和 set 方法，可通過下標(biāo)獲取 / 設(shè)置數(shù)組- 值。
• 創(chuàng)建方式：方式1 = 函數(shù)arrayOf()；方式2 = 工廠函數(shù)、

// 方式1：使用arrayOf創(chuàng)建1個(gè)數(shù)組：[1,2,3]
val a = arrayOf(1, 2, 3)

// 方式2：使用工廠函數(shù)創(chuàng)建1個(gè)數(shù)組[0,2,4]
val b = Array(3, { i -> (i * 2) })
// 工廠函數(shù)源碼分析
// 參數(shù)1 = 數(shù)組長(zhǎng)度，花括號(hào)內(nèi)是一個(gè)初始化值的代碼塊，給出數(shù)組下標(biāo) & 初始化值
public inline constructor(size: Int, init: (Int) -> T)

// 讀取數(shù)組內(nèi)容
println(a[0])    // 輸出結(jié)果：1
println(b[1])    // 輸出結(jié)果：2

// 特別注意：除了類Array，還有ByteArray, ShortArray, IntArray用來表示各個(gè)類型的數(shù)組
// 優(yōu)點(diǎn)：省去了裝箱操作，因此效率更高
// 具體使用：同Array
val x: IntArray = intArrayOf(1, 2, 3)

注： 區(qū)別于Java，Kotlin中的數(shù)組是不型變的（invariant），即Kotlin 不允許將Array賦值給Array，以防止可能的運(yùn)行時(shí)失敗

4.3 類使用

a. 類的聲明 & 實(shí)例化

• 實(shí)現(xiàn)方式：使用Array類
• 使用方法：size 屬性、get方法和set 方法。注：使用 [] 重載了 get 和 set 方法，可通過下標(biāo)獲取 / 設(shè)置數(shù)組值。
• 創(chuàng)建方式：方式1 = 函數(shù)arrayOf()；方式2 = 工廠函數(shù)

// 格式
class 類名（參數(shù)名1：參數(shù)類型，參數(shù)名2：參數(shù)類型...）{}

//示例
class User(userName: String, age: Int){}

// Kotlin支持默認(rèn)參數(shù)，即在調(diào)用函數(shù)時(shí)可不指定參數(shù)，則使用默認(rèn)函數(shù)
class User(userName: String = "hjc", age: Int = 26){
}
// 在實(shí)例化類時(shí)不傳入?yún)?shù)，userName默認(rèn) = hjc，age默認(rèn) = 26
var user = User()
// 在設(shè)置默認(rèn)值后，若不想用默認(rèn)值可在創(chuàng)建實(shí)例時(shí)傳入?yún)?shù)
var user = User("ABC" , 123)
// 命名參數(shù)：若一個(gè)默認(rèn)參數(shù)在一個(gè)無默認(rèn)值的參數(shù)前，那么該默認(rèn)值只能通過使用命名參數(shù)調(diào)用該函數(shù)來使用
class User(userName: String = "hjc", age: Int)
var  user = User(age = 26)

// Kotlin沒有new關(guān)鍵字，所以直接創(chuàng)建類的實(shí)例：
User()

對(duì)于構(gòu)造函數(shù)，Kotlin中類可有一個(gè)主構(gòu)造函數(shù) & 多個(gè)次構(gòu)造函數(shù)，下面將詳細(xì)說明。

b. 主構(gòu)造函數(shù)

• 屬于類頭的一部分 = 跟在類名后，采用 constructor 關(guān)鍵字
• 不能包含任何的代碼。初始化的代碼放到以 init 關(guān)鍵字作為前綴的代碼塊中

// 形式
class 類名 constructor（參數(shù)名：參數(shù)類型）{
    init {       
    //...
    }
}

// 示例
class User constructor(userName: String) {
    init {       
    //...
    }
}

注：若主構(gòu)造函數(shù)無任何注解 / 可見性修飾符，可省略 constructor 關(guān)鍵字

// 形式
class 類名（參數(shù)名：參數(shù)類型）{
    init {       
    //...
    }
}

// 示例
class User (userName: String) {
    init {       
    //...
    }
}

c. 次構(gòu)造函數(shù)

• 必須加constructor關(guān)鍵字
• 一個(gè)類中可存在多個(gè)次構(gòu)造函數(shù)，傳入?yún)?shù)不同

// 形式
constructor(參數(shù)名：參數(shù)類型) :{函數(shù)體}

// 示例
class User(userName: String) {
    // 主構(gòu)造函數(shù)
    init {
        println(userName)
    }

    // 次構(gòu)造函數(shù)1：可通過this調(diào)主構(gòu)造函數(shù)
    constructor() : this("hjc")

    // 次構(gòu)造函數(shù)2：可通過this調(diào)主構(gòu)造函數(shù)
    constructor(age: Int) : this("hjc") {
        println(age)
    }

    // 次構(gòu)造函數(shù)3：通過this調(diào)主構(gòu)造函數(shù)
    constructor(sex: String, age: Int) : this("hjc") {
        println("$sex$age")
    }
}

// 實(shí)例化類
User("hjc") // 調(diào)用主構(gòu)造函數(shù)
User()      // 調(diào)用次構(gòu)造函數(shù)1
User(2)     // 調(diào)用次構(gòu)造函數(shù)2
User("male",26) // 調(diào)用次構(gòu)造函數(shù)3

d. 類的屬性

Kotlin的類可以擁有屬性：關(guān)鍵字var（讀寫） / 關(guān)鍵字val（只讀）

class User {
    var userName: String
    val sex: String = "男"
}

// 使用屬性 = 名稱 + 引用
User().sex  // 使用該屬性 = Java的getter方法
User().userName = "hjc"  // 設(shè)置該屬性 = Java的setter方法

e. 可見性修飾符

• private ：本類內(nèi)部都可見
• protected ：本類內(nèi)部 & 子類中可見
• public：能見到類聲明的任何客戶端都可以見（public成員）
• internal：能見到類聲明的本模塊內(nèi)的任何客戶端都可見（public成員）

區(qū)別于Java，Kotlin的可見修飾符少了default，多了internal：該成員只在相同模塊內(nèi)可見。（注：一個(gè)模塊 = 編譯在一起的一套 Kotlin 文件：
一個(gè) IntelliJ IDEA 模塊；
一個(gè) Maven 項(xiàng)目；
一個(gè) Gradle 源集；
一次 ＜kotlinc＞ Ant 任務(wù)執(zhí)行所編譯的一套文件。

f. 繼承 & 重寫

• 類似于Java，Kotlin是單繼承 = 只有一個(gè)父類
• 區(qū)別：Kotlin使用冒號(hào)“ : ”繼承 & 默認(rèn)不允許繼承（若想讓類可被繼承，需用open關(guān)鍵字來標(biāo)識(shí)）

// 用open關(guān)鍵字標(biāo)識(shí)該類允許被繼承
open class Food 

// 類Fruits繼承類Food
class Fruits : Food()

• 對(duì)于子類重寫父類的方法，在Kotlin中，方法也是默認(rèn)不可重寫的
• 若子類要重寫父類中的方法，則需在父類的方法前面加open關(guān)鍵字，然后在子類重寫的方法前加override關(guān)鍵字

// 父類
// 在類 & 方法前都加了關(guān)鍵字open，為了被繼承 & 方法重寫
open class Food {
    open fun banana() {}
}

// 子類 
class Fruits : Food(){
    // 重寫了父類的方法
    override fun banana() {
        super.banana()
    }
}

特殊類說明

下面將講解一些特殊的類：

• 嵌套類（內(nèi)部類）
• 接口
• 數(shù)據(jù)類
• 枚舉類

/**
 * 1. 嵌套類（內(nèi)部類）
 * 標(biāo)識(shí)：關(guān)鍵字inner
 * 使用：通過外部類的實(shí)例調(diào)用嵌套類
 */
 class User {
    var age: Int = 0

    inner class UserName {
    }
}

var userName: User.UserName  = User().UserName()


/**
 * 2. 接口
 * 標(biāo)識(shí)：關(guān)鍵字interface
 */
// 聲明
interface A{}
interface B{}

// 方法體
// 接口中的方法可以有默認(rèn)方法體，有默認(rèn)方法體的方法可不重寫
// 區(qū)別于Java：Java不支持接口里的方法有方法體。
interface UserImpl{
    fun getName(): String // 無默認(rèn)方法體，必須重寫
    fun getAge(): Int{    // 有默認(rèn)方法體，可不重寫
        return 22
    }
}
// 實(shí)現(xiàn)接口UserImpl：需重寫getName() & 可不重寫getAge()
class User :UserImpl{
    override fun getName(): String {
        return "hjc"
    }
}

// 實(shí)現(xiàn)接口：冒號(hào):
class Food : A, B {} // Kotlin是多實(shí)現(xiàn)
class Fruits: Food,A, B {} // 繼承 + 實(shí)現(xiàn)接口

 /**
  * 3. 數(shù)據(jù)類
  * 作用：保存數(shù)據(jù)
  * 標(biāo)識(shí)：關(guān)鍵字data
 */
// 使用：創(chuàng)建類時(shí)會(huì)自動(dòng)創(chuàng)建以下方法：
//      1. getter/setter方法；
//      2. equals() / hashCode() 對(duì)；
//      3. toString() ：輸出"類名(參數(shù)+參數(shù)值)"；
//      4. copy() 函數(shù)：復(fù)制一個(gè)對(duì)象&改變它的一些屬性，但其余部分保持不變

// 示例：
// 聲明1個(gè)數(shù)據(jù)類
data class User(var userName: String, var age: Int)
// copy函數(shù)使用
var user = User("hjc",26)
var user1 = user.copy(age = 30)
// 輸出user1.toString()，結(jié)果是：User(userName=hjc,age=30)

// 特別注意
// 1. 主構(gòu)造方法至少要有一個(gè)參數(shù)，且參數(shù)必須標(biāo)記為val或var
// 2. 數(shù)據(jù)類不能用open、abstract、sealed(封閉類)、inner標(biāo)識(shí)

/**
 * 4. 枚舉類
 * 標(biāo)識(shí)：關(guān)鍵字enum
 */
 // 定義
 enum class Color {
    RED, GREEN, BLUE
}

// 為枚舉類指定值
enum class Color(rgb: Int) {
    RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF)
}

4.4 變量 & 常量

// 變量
    // 模板： var 變量名：數(shù)據(jù)類型 = 具體賦值數(shù)值
    // 規(guī)則：
    //      1. 采用 “var” 標(biāo)識(shí)
    //      2. 變量名跟在var后；數(shù)據(jù)類型在最后
    //      3. 變量名與數(shù)據(jù)類型采用冒號(hào) ":" 隔開
    // 示例：
            var a: Int = 1 
            var a: Int 
            a = 2

// 常量
    // 模板： val 常量名：數(shù)據(jù)類型 = 具體賦值數(shù)值
    // 規(guī)則：
    //      1. 采用 “val” 標(biāo)識(shí)
    //      2. 常量名跟在val后；數(shù)據(jù)類型在最后
    //      3. 常量名與數(shù)據(jù)類型采用冒號(hào) ":" 隔開
    // 示例：
            val a: Int // 聲明一個(gè)不初始化的變量，必須顯式指定類型
            a = 2 // 常量值不能再次更改
            val b: Int = 1 // 聲明并顯示指定數(shù)值

// 特別注意：1. 自動(dòng)類型轉(zhuǎn)換 & 判斷數(shù)據(jù)類型
    // 1. 自動(dòng)類型轉(zhuǎn)換
    // 在定義變量 / 常量時(shí)，若直接賦值，可不指定其數(shù)據(jù)類型，則能自動(dòng)進(jìn)行類型轉(zhuǎn)換。如：
    var a = "aaa" // 此處a的數(shù)據(jù)類型是String類型
    val b = 1 // 此處的b的數(shù)據(jù)類型是Int類型

    // 2. 判斷數(shù)據(jù)類型：運(yùn)算符is
    n is Int // 判斷n是不是整型類型

4.5 函數(shù)

a. 定義 & 調(diào)用

// 模板：
  fun 函數(shù)名（參數(shù)名：參數(shù)類型）：返回值類型{
    函數(shù)體
    return 返回值
}

// 說明：
//      1. 采用 “fun” 標(biāo)識(shí)
//      2. 括號(hào)里的是傳入函數(shù)的參數(shù)值和類型

// 示例：一個(gè)函數(shù)名為“abc”的函數(shù)，傳入?yún)?shù)的類型是Int，返回值的類型是String
 fun abc(int: Int): String {
    return "carson_ho"
}

// 特別注意：存在簡(jiǎn)寫方式，具體示例如下：
// 正常寫法
fun add(a: Int, b: Int): Int {
    return a + b
}
// 簡(jiǎn)寫：若函數(shù)體只有一條語句 & 有返回值，那么可省略函數(shù)體的大括號(hào)，變成單表達(dá)式函數(shù)
fun add(a: Int, b: Int) = a + b;

// 調(diào)用函數(shù)：假設(shè)一個(gè)類中有一個(gè)foo的函數(shù)方法
User().foo()

b. 默認(rèn)參數(shù)

// 給int參數(shù)指定默認(rèn)值為1
fun foo(str: String, int: Int = 1) {
    println("$str  $i")
}

// 調(diào)用該函數(shù)時(shí)可不傳已經(jīng)設(shè)置了默認(rèn)值的參數(shù)，只傳無設(shè)默認(rèn)值的參數(shù)
foo("abc")
// 結(jié)果： abc  1

// 注：若有默認(rèn)值的參數(shù)在無默認(rèn)值的參數(shù)前，要略過有默認(rèn)值的參數(shù)去給無默認(rèn)值的參數(shù)指定值，需用命名參數(shù)來指定值
// 有默認(rèn)值的參數(shù)（int）在無默認(rèn)值的參數(shù)（str）前
fun foo(int: Int = 1, str: String) {
    println("$str  $i")
}

// 調(diào)用
foo(str = "hello")  // 使用參數(shù)的命名來指定值
// 結(jié)果： hello  1

foo("hello")  // 出現(xiàn)編譯錯(cuò)誤

c. 特別注意

一個(gè)函數(shù)，除了有傳入?yún)?shù) & 有返回值的情況，還會(huì)存在：

• 有傳入?yún)?shù) & 無返回值
• 無傳入?yún)?shù) & 無返回值

// 有傳入?yún)?shù) & 無返回值
    // 模板：
      fun 函數(shù)名（參數(shù)名：參數(shù)類型）{
        函數(shù)體
    }
    // 或返回Unit（類似Java的void，無意義）
      fun 函數(shù)名（參數(shù)名：參數(shù)類型）：Unit{
        函數(shù)體
    }

// 無傳入?yún)?shù) & 無返回值
    // 模板：
      fun 函數(shù)名（）{
        函數(shù)體
    }
    // 或返回Unit（類似Java的void，無意義）
      fun 函數(shù)名（）：Unit{
        函數(shù)體
    }

4.6 其他語法糖

關(guān)于Kotlin的一些實(shí)用語法糖，主要包括：

• 控制流（if、when、for、 while）
• 范圍使用（in、downTo、step、until）
• 類型檢查 & 轉(zhuǎn)換（is、智能轉(zhuǎn)換、as）
• 相等性（equals（）、=、 ==）
• 空安全

a. 控制流語句

控制流語句主要包括：if、when、for 和 while。

if語句

• Kotlin中的if語句與Java用法類似
• 區(qū)別在于：Kotlin的if語句本身是一個(gè)表達(dá)式，存在返回值

var c = if (a > b) 3 else 4

// 若a > b，則返回3給c
// 若a < b，則返回4給c
// 類似Java中的三元表達(dá)式
c = a > b ? 3 : 4; // 若a>b，c=3，否則c=4

// 若if后面是代碼塊
var c = if (a > b) {
    代碼塊1
} else {
    代碼塊2
}
// 若a > b，則執(zhí)行代碼塊1，否則執(zhí)行代碼塊2

when語句

類似Java中的switch語句

// Java中的Switch語句
int a = 0;
switch (a) {
    case 0:
        break;
    case 1:
        break;
    default:
        break;
}

// Kotlin中的when語句
var a = 0
when (a) {
    0 -> {代碼塊1}
    1 -> {代碼塊2}
    2,3 -> {代碼塊3}
    else -> {代碼塊4}
}
// 說明：
// 當(dāng)a=0時(shí)執(zhí)行代碼塊1
// 當(dāng)a=1時(shí)執(zhí)行代碼塊2
// 當(dāng)a=2，3時(shí)，執(zhí)行代碼塊3
// 當(dāng)a=其他值時(shí)，執(zhí)行代碼塊4

// 注意：when語句在滿足條件的分支執(zhí)行后，會(huì)終止when語句執(zhí)行

for語句

類似Java中的for語句

// 示例1：表達(dá)一個(gè)數(shù)字是否在目的范圍內(nèi)
// Java中的for語句
for (int i = 0; i < 4; i++) {
    System.out.println(i);
}
// Kotlin中的for語句
if (i in 1..4){ 
    println(i)
}
// 注：關(guān)鍵字用于表示數(shù)字是否在目標(biāo)范圍內(nèi)，上面的示例表示判斷i是否在代表1-4范圍內(nèi)

// 示例2：通過索引遍歷一個(gè)數(shù)組
// Java中的for語句
for (int i = 0; i < 4; i++) {
    System.out.println(i);
}
// Kotlin中的for語句
for (i in array.indices) {
    println(array[i])
}

while語句

類似Java中的while語句，分為while 和 do…while語句：

var i = 5

while(i in 1..4){
   代碼塊1
}

do{ 代碼塊2
  }while(i in 1..4){
}

b. 范圍使用

主要用于表示范圍，主要包括：in、downTo、step、until

/**
 *  1. in
 *  作用：在...范圍內(nèi)
 **/
// 表示：若i在1-5范圍內(nèi)，則執(zhí)行下面代碼
// 注：閉區(qū)間，[1,5]
if (i in 1..5) {
    println("i 在 1-5 內(nèi)")
}

// 表示：若i不在1-5范圍內(nèi)，則執(zhí)行下面代碼
// !in表示不在...范圍內(nèi)
if (i !in 1..5) {
    println("i 不在 1-5 內(nèi)")
}

/**
 *  2. until
 *  作用：表示開區(qū)間
 **/
// 輸出1234
for (i in 1 until 5) {
 println(i)
}

/**
 *  3. downTo
 *  作用：倒序判斷
 **/
 for (i in 5 downTo 1) {
    println(i)
 }

/**
 *  4. step
 *  作用：調(diào)整步長(zhǎng)
 **/
// 設(shè)置步長(zhǎng)為2，順序輸出1、3、5
for (i in 1..5 step 2) println(i) 

// 設(shè)置步長(zhǎng)為2，倒序輸出5、3、1
for (i in 1 downTo 5 step 2) println(i) 

c. 類型檢查 & 轉(zhuǎn)換

/**
 *  1. is
 *  作用：判斷一個(gè)對(duì)象與指定的類型是否一致
 **/
// 判斷變量a的數(shù)據(jù)類型是否是String
var a: Any = "a"
if (a is String) {
    println("a是String類型")
}
if (a !is Int) {
    println("a不是Int類型")
}

/**
 *  2. 智能轉(zhuǎn)換
 *  說明： kotlin不必使用顯式類型轉(zhuǎn)換操作，因?yàn)榫幾g器會(huì)跟蹤不可變值的is檢查以及顯式轉(zhuǎn)換，并在需要時(shí)自動(dòng)插入（安全的）轉(zhuǎn)換
 **/
 var a: Any = "a"
if (a is String) {
    println("a是String類型")
    println(a.length) // a 自動(dòng)轉(zhuǎn)換為String類型
    //輸出結(jié)果為：1
}

// 反向檢查： a自動(dòng)轉(zhuǎn)換為String類型
if (a !is String) {
    print(a.length)
}

// 在 && 和 || 的右側(cè)也可以智能轉(zhuǎn)換：
// `&&` 右側(cè)的 a 自動(dòng)轉(zhuǎn)換為String
if (a is String && a.length > 0)
// `||` 右側(cè)的 a 自動(dòng)轉(zhuǎn)換為String
if (a is String || a.length > 0)

// 在when表達(dá)式和while循環(huán)里也能智能轉(zhuǎn)換：
when(a){
    is String -> a.length
    is Int -> a + 1
}

// 需要注意：當(dāng)編譯器不能保證變量在檢查和使用之間不可改變時(shí)，智能轉(zhuǎn)換不能用。智能轉(zhuǎn)換能否適用根據(jù)以下規(guī)則：
// 1. val 局部變量——總是可以，局部委托屬性除外；
// 2. val 屬性——如果屬性是 private 或 internal，或者該檢查在聲明屬性的同一模塊中執(zhí)行。智能轉(zhuǎn)換不適用于 open 的屬性或者具有自定義 getter 的屬性；
// 3. var 局部變量——如果變量在檢查和使用之間沒有修改、沒有在會(huì)修改它的 lambda 中捕獲、并且不是局部委托屬性；
// 4. var 屬性——決不可能（因?yàn)樵撟兞靠梢噪S時(shí)被其他代碼修改）

/**
 *  3. 強(qiáng)制類型轉(zhuǎn)換：as
 **/
var any: Any = "abc"
var str: String = any as String

// 強(qiáng)制類型轉(zhuǎn)換是不安全的，若類型不兼容則會(huì)拋出一個(gè)異常
var int: Int = 123
var str: String = int as String
// 拋出ClassCastException

/**
 *  4. 可空轉(zhuǎn)換操作符：as？
 *  作用：null不能轉(zhuǎn)換為String，因該類型不是可空的，此時(shí)使用可空轉(zhuǎn)換操作符as?
 **/
var str = null
var str2 = str as String
// 拋出TypeCastException

// 使用安全轉(zhuǎn)換操作符as?可以在轉(zhuǎn)換失敗時(shí)返回null，避免了拋出異常。
var str = null
var str2 = str as? String
println(str2) //輸出結(jié)果為：null

d. 相等性判斷

在Kotlin中，存在結(jié)構(gòu)相等 & 引用相等 兩種相等判斷。

/**
 *  1. 結(jié)構(gòu)相等：equals()或 ==
 *  作用：判斷兩個(gè)結(jié)構(gòu)是否相等
 **/
var a = "1"
var b = "1"
if (a.equals(b)) {
    println("a 和 b 結(jié)構(gòu)相等")
    // 輸出結(jié)果為：a 和 b 結(jié)構(gòu)相等
}

var a = 1
var b = 1
if (a == b) {
    println("a 和 b 結(jié)構(gòu)相等")
    // 輸出結(jié)果為：a 和 b 結(jié)構(gòu)相等
}

/**
 *  2. 引用相等：===
 *  作用：判斷兩個(gè)引用是否指向同一對(duì)象
 */ 
// 設(shè)置一個(gè)類如下
data class User(var name: String, var age: Int)

// 設(shè)置值
var a = User("Czh", 22)
var b = User("Czh", 22)
var c = b
var d = a

// 對(duì)比兩個(gè)對(duì)象的結(jié)構(gòu)
if (c == d) {
    println("a 和 b 結(jié)構(gòu)相等")
} else {
    println("a 和 b 結(jié)構(gòu)不相等")
}

// 對(duì)比兩個(gè)對(duì)象的的引用
if (c === d) {
    println("a 和 b 引用相等")
} else {
    println("a 和 b 引用不相等")
}

// 輸出結(jié)果：
a 和 b 結(jié)構(gòu)相等
a 和 b 引用不相等

e. 空安全

在Java中，NullPointerException異常十分常見
而Kotlin的優(yōu)點(diǎn)則是可以盡可能避免執(zhí)行代碼時(shí)出現(xiàn)的空指針異常
/**
 *  1. 可空類型與非空類型
 *  在Kotlin中，有兩種情況最可能導(dǎo)致出現(xiàn)NullPointerException
 **/

// 情況1：顯式調(diào)用 throw NullPointerException()
// 情況2：使用!! 操作符
// 說明：!!操作符將任何值轉(zhuǎn)換為非空類型，若該值為空則拋出異常
var a = null
a!!
// 拋出KotlinNullPointerException

// 情況3：數(shù)據(jù)類型不能為null
// 在 Kotlin 中，類型系統(tǒng)區(qū)分一個(gè)引用可以容納 null （可空引用） 和 不能容納（非空引用）
// 如：String類型變量不能容納null
// 若要允許為空，可聲明一個(gè)變量為可空字符串：在字符串類型后面加一個(gè)問號(hào)?
對(duì)于String，則是寫作：String?
var b: String? = "b"
b = null


/**
 *  2. 安全調(diào)用操作符
 *  作用：表示如果若不為null才繼續(xù)調(diào)用
 **/
 b?.length
 // 表示：若b不為null，才調(diào)用b.length

 // 注：安全調(diào)用符還可以鏈?zhǔn)秸{(diào)用
 a?.b?.c?.d
 // 假設(shè)a不為null，才繼續(xù)往下調(diào)用，以此類推
 // 若該鏈?zhǔn)秸{(diào)用中任何一個(gè)屬性為null，整個(gè)表達(dá)式都會(huì)返回null。
 // 若只對(duì)非空值執(zhí)行某個(gè)操作，可與let一起使用
a?.b?.let { println(it) }

至此，關(guān)于Kotlin的入門語法講解完畢。

5. 總結(jié)

• 本文全面介紹了Kotlin入門學(xué)習(xí)知識(shí)，包括定義特點(diǎn)、配置使用、入門語法等
• 接下來推出的文章，我將繼續(xù)講解Kotlin的相關(guān)知識(shí)，包括使用、語法特點(diǎn)等，感興趣的讀者可以繼續(xù)關(guān)注博客哦：Carson_Ho的Android博客

轉(zhuǎn)發(fā)至https://juejin.im/entry/5d36609ff265da1b88121bc3