【基礎篇】Kotlin第五講-類型和空處理

Kotlin的類型

類型就是數據的分類，不同類型代表不同種類的數據。

Kotlin裏類型分爲：可空類型，非空類型，平臺類型

對平臺類型的理解

**平臺類型：**Kotlin不知道可空性信息的類型，即當作可空類型也可當作非空類型。所以在這個類型上的所有操作需要程序員自己負責，編譯器允許所有的操作。通常發生在Kotlin調用Java代碼的場景上。

以字符串類型舉例，字符串平臺類型如下：

String！

程序員不能使用這種語法，Java代碼轉Kotlin代碼的時候會出現，表示可控性未知，也可以理解爲己有肯能是非空類型也有可能是可空類型

非空類型和可空類型的理解

可空類型 = 非空類型 + null

Type? = Type + null

因此，String？，String是兩種不同的數據類型，就像Int和String是兩種數據類型那般。

基本數據類型

Kotlin不區分基本數據類型和包裝類型，都是使用一種基本類型：

下面是非空基本類型

Char, Boolean, Byte, Short, Int，Long, Float, Double

可空基本類型

Char？, Boolean?, Byte?, Short?, Int?，Long?, Float?, Double?

Kotlin的基本類型如果轉成Java基本數據類型，要怎麼辦？

對於變量、屬性、參數和返回類型，Kotlin的基本類型會被編譯成Java的基本數據類型。
用作泛型類型參數的基本數據類型會被編譯成對應的Java包裝類型。

注意：

和Java不同，大範圍的值不能自動轉化爲小範圍的值，而是看成兩種不同的類型

下面的代碼演示了數據類型的表示，各類型轉化，數據類型智能推斷，字符串類型轉成基本數據類型

fun testBasicType() {
    val bb: Byte = 127
    val boolean = false
    val aa: Char = 'a'

    var i: Int = 21_4748_3647 //10位
    var l: Long = 922_3372_0368_5477_5807L  //19位 //不存在小寫的l

    val f: Float = 123f
    val f2: Float = 124F

    val a16 = 0x123ef3
    val b16 = 0XcCCef3

    val c2 = 0b1010
    val cc2 = 0B11001

    val b: Byte = 1

    val eas = b + 1L //Long + Byte => Long , eas爲Long類型

    fun foo(l: Long) {
        println(l)
    }

    foo(44) //單獨寫44可能是byte，int long，這裏智能推斷44會被認爲是long

    //字符串轉基本數據類型
    val p = "44".toInt()
    val p2 = "44".toLong()
    val p3 = "44".toFloatOrNull()
    val p4 = "44".toDouble()

    val translate = l.toInt().toLong().toFloat().toDouble().toInt()
}

Any，Unit，Nothing類型

Any 相當於 Object，不同點：是非空類型，缺少Object的wait，notify方法

Unit相當於Java的Void；不同點：Unit是一個完備的類型，可以作爲類型參數。Unit是Any的子類

Nothong表明函數不會有返回類型（沒有返回類型），該函數不會正常終止，Nothing是Unit的子類

fun getStrinLenght(s: String?): Int {
    if (s == null) {
        throw IllegalArgumentException()
    } else {
        return s.length
    }
}

fun fail(): Nothing = throw IllegalArgumentException()

fun getStrinLenght2(s: String?): Int =
        if (s == null) {
            fail()
        } else {
            s.length
        }

fun testAnyAndNothing(o: Any?): View {
    val filterO = o ?: fail()

    return when (filterO) {
        is View -> {
            View("View")
        }
        is TextView -> {
            TextView("TextView", "")
        }
        else -> {
            fail()
        }
    }
}

可以認爲：throw IllegalArgumentException()返回的類型是Nothing，nothing是Int的子類型。

小結

Any，Unit和Nothing三者關係： A Whirlwind Tour of the Kotlin Type Hierarchy

空安全相關的運算符

安全調用？.

如果值是null，整個表達式的值爲null。

open class Company(val name: String, val address: String?)

fun testNullType(){
    val company = Company("京東", null)

    val length = company.address?.length
    println("length = $length")
}

Elvis運算符 ？：

fun testElvis(list: List<Company?>?, defaultAddress: String?){
    val defaultAdd = defaultAddress ?: ""
    val length = defaultAddress?.length ?: 0 //.?爲空調用，表達式返回null，遇到了？：
    println("defaultAdd = $defaultAdd, length = $length")

    val companyList = list ?: throw IllegalArgumentException("null list")

    val address = companyList[0]?.address?.toUpperCase() ?: defaultAddress //多重空安全調用和Elvis聯合使用
    println("address = $address")
}

安全轉換as?

as？運算法嘗試把值轉換成制定的類型，如果值不是合適的類型就返回null。

open class View(val name: String)

class TextView(name: String, val text: String) : View(name)

fun testAsClient(){
    val company = Company("JD", "亦莊")
    testAs(company)

    testAs2(company)

    val tv = TextView("TextView", "I am a message content")
    testAs2(tv)
}

fun testAs(o: Any){
    val tv = o as TextView
    println("name = ${tv.name}")
}

fun testAs2(o: Any){
    val tv = o as? TextView ?: TextView("Default TextView", "")
    println("The content of ${tv.name} is = ${tv.text}")
}

非空斷言 !!

把任何值轉換成非空類型

fun testNoNullClient(){
    val result = testNoNull("Kotlin")
    println("result = $result")
}

fun testNoNull(s: String?) : String{
    val length = s!!.length
    println("$s's length is $length")
    return s!!.toUpperCase()
}

let函數

把可空值作爲實參傳遞一個只接收非空值的函數

fun testLet(){
    val length = getTheBigCompanyInTheWorld().address?.length
    val upperCase = getTheBigCompanyInTheWorld().address?.toUpperCase()
    val letter = getTheBigCompanyInTheWorld().address?.get(0)
    println("address's length is $length , uppercase  = $upperCase, letter = $letter")
}

fun testLet2(){
    getTheBigCompanyInTheWorld().address?.let {
        val upperCase = it.toUpperCase()
        val length = it.length
        val letter = it[0]
        println("address's length is $length , uppercase  = $upperCase, letter = $letter")
    }
}

fun getTheBigCompanyInTheWorld(): Company = Company("JD", "Beijing")

可空類型的擴展函數

允許接收者爲null的調用，在擴展函數內部處理null。不需要安全調用了

看幾個Kotlin標準庫，String定義的擴展函數isNullOrEmpty

public inline fun CharSequence?.isNullOrEmpty(): Boolean {
    return this == null || this.length == 0
}

注意：

在Java中，this永遠是非空的，在Kotlin中，this可以爲null。

因此在定義擴展函數時，需要考慮擴展是否需要爲可空類型定義。本質上是對null在哪個環節處理的思考，是要在調用時使用空安全調用處理呢，還是在調用的函數內部處理。

泛型參數默認是可空類型

fun <T> myPrintln(t: T){
    println(t.toString())
}

fun testGenericityClient(){
    myPrintln(null)
}

轉Java代碼爲Kotlin代碼時，對空的處理

帶註解的Java變量翻譯到Kotlin時被認爲是可空類型或者非空類型

1. Javax.annotation包下
2. android.support.annotation包下
3. org.jetbrains.annotations下

@Nullable + Type = Type?
@NotNull + Type = Type

參考資料

Kotlin實戰