【基础篇】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实战