《Kotlin核心编程》笔记：可空类型&平台类型&装箱类型&数组类型&泛型&协变与逆变

可空类型

在Kotlin中，我们可以在任何类型后面加上“?”，比如“Int?”，实际上等同于“Int? = Int or null”。

通过合理的使用，不仅能够简化很多判空代码，还能够有效避免空指针异常。

注意：由于null只能被存储在 Java 的引用类型的变量中，所以在 Kotlin 中基本数据的可空版本都会使用该类型的包装形式。同样，如果你用基本数据类型作为泛型类的类型参数，Kotlin同样会使用该类型的包装形式。(即可空类型会自动装箱)

Java中对于null的一些解决方案：

• 函数内对于无效值，可以抛异常处理。
• 采用@NotNull/@Nullable标注。
• 使用专门的Optional对象对可能为null的变量进行装箱。

可空类型相关的安全操作符

安全的调用 ?.

s.student?.glasses?.degreeOfMyopia

Elvis操作符 ?:

val result = student.glasses?.degreeOfMyopia ?: -1

又称合并运算符

非空断言 !!

val result = student!!.glasses

类型检查

在Kotlin中，我们可以用“is”来判断。

if (obj is String) {
    print(obj.length)
}

if (obj !is String) { // 等同于 !(obj is String)
    print("Not a String")
} else {
    print(obj.length)
}

when (obj) {
    is String -> print(obj.length)
    !is String -> print("Not a String")
}

类型智能转换

Smart Casts 可以将一个变量的类型转变为另一种类型，它是隐式完成的。

val stu: Any = Student(Glasses(189.00)) 
if(stu is Student) println(stu.glasses) 

对于可空类型，我们可以使用 Smart Casts：

val stu: Student = Student(Glasses(189.00))
if (stu.glasses != null) println(stu.glasses.degreeOfMyopia) 

我们将这个例子反编译成Java，核心代码如下

...
Intrinsics.checkParameterlsNotNull(args, "args"); 
Student stu = new Student(new Glasses(189.0D)); 
if (stu instanceof Student) {
	Glasses var2 = ((Student)stu).getGlasses(); 
	System.out.println(var2);
}
...

我们可以看到，这与我们写的Java版本一致，这其实是Kotlin的编译器帮我们做出了转换。

根据官方文档介绍：当且仅当Kotlin的编译器确定在类型检查后该变量不会再改变，才会产生SmartCasts。

利用这点，我们能确保多线程的应用足够安全。举个例子：

class Kot {
    var stu: Student? = getStu()
    
    fun dealStu() {
        if (stu != null) {
            print(stu.glasses)
        }
    }
}

上述代码中，我们将stu声明为引用可空类型变量，这意味着在判断 stu != null 之后，stu在其他线程中还是会被修改的，所以被编译器无情地拒绝了。

将var改为val就不会存在这样的问题，引用不可变能够确保程序运行不产生额外的副作用。你也许会觉得这样写不够优雅，我们可以用let函数来简化⼀下：

class Kot {
    var stu: Student? = getStu()
    
    fun dealStu() {
        stu?.let { print(it.glasses) }
    }
}

这样就会满足 Smart Casts 的条件，就不会被拒绝编译。

在实际开发中，我们并不总能满足 Smart Casts 的条件。并且 Smart Casts 有时会缺乏语义，并不适用于所有场景。

当类型需要强制转换时，我们可以利用“ as” 操作符来实现。

class Kot {
    val stu: Student? = getStu() as Student?
    
    fun dealStu() {
        if (stu != null) {
            print(stu.classes)
        }
    }
}

由于val只允许赋值一次，这样，我们在外部已经确定了stu的类型，当stu不为空时，在dealStu方法里就可以成功调用stu的参数。

注意：

• 这里stu变量是在dealStu()方法的外面，必须使用val生声明，否则如果是var，仍然可能有线程安全问题所以也会被拒绝编译。
• 如果stu变量是放在dealStu()方法的里面，那么可以使用var, 因为是方法本地局部变量，会被线程独占，此时也满足 Smart Casts 的条件。

因为getStu可能为空，如果我们将其转换类型改为 Student：

val stu: Student? = getStu() as Student

则会抛出类型转换失败的异常，因为它不是可空的。所以，我们通常称之为“ 不安全” 的类型转换。

那是否有安全版本的转换呢？除了上述写法外，Kotlin还提供了操作符“ as?”，我们可以这样改写：

val stu: Student? = getStu() as? Student

这时，如果stu为空将不会抛出异常，而是返回转换结果null。

Any：非空类型的根类型

与 Object 作为 Java 类层级结构的顶层类似，Any 类型是 Kotlin 中所有非空类型（如String、Int）的超类：

与 Java 不同的是，Kotlin 不区分“原始类型”（primitivetype）和其他的类型，它们都是同一类型层级结构的一部分。

如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如：

class Animal(val weight: Double) 

如果你为定义的类型指定了父类型，则该父类型将是新类型的直接父类型，但是新类型的最终根类型为Any。

另外，Kotlin 把 Java 方法参数和返回类型中用到的 Object 类型看作 Any（更确切地说是当作“平台类型”）。当在 Kotlin 函数中使用 Any 时，它会被编译成 Java 字节码中的 Object。

什么是平台类型？

平台类型本质上就是 Kotlin 不知道可空性信息的类型，所有 Java 引用类型在 Kotlin 中都表现为平台类型。当在 Kotlin 中处理平台类型的值的时候，它既可以被当作可空类型来处理，也可以被当作非空类型来操作。

平台类型的引入是 Kotlin 兼容 Java 时的一种权衡设计。试想下，如果所有来自 Java 的值都被看成非空，那么就容易写出比较危险的代码。反之，如果 Java 中的值都强制当作可空，则会导致大量的 null 检查。综合考量，平台类型是一种折中的设计方案。

Any？：所有类型的根类型

如果说Any是所有非空类型的根类型，那么 Any? 才是所有类型（可空和非空类型）的根类型。
Any 与 Any? 看起来没有继承关系，然而在我们需要用 Any? 类型值的地方，显然可以传入一个类型为Any的值，这在编译上不会产生问题。比如在 Kotlin 中 Int 是 Number 的子类：

fun printNum(num : Number){
    println(num)
}

val n : Int = 1
printNum(n)

反之却不然，比如一个参数类型为Any的函数，我们传入符合 Any? 类型的null值，就会出现如下的错误：

error: null can not be a value of a non-null type Any 

Nothing 与 Nothing？

在 Kotlin 类型层级结构的最底层是 Nothing 类型。

Nothing是没有实例的类型。Nothing类型的表达式不会产生任何值。需要注意的是，任何返回值为Nothing的表达式之后的语句都是无法执行的。你是不是感觉这有点像return或者break的作用？没错，Kotlin 中 return、throw 等（流程控制中与跳转相关的表达式）返回值都为Nothing。

Nothing? 是 Nothing 的父类型，其实，它只能包含一个值：null，本质上与null没有区别。所以我们可以使用null作为任何可空类型的值。

自动装箱与拆箱

我们发现，Kotlin 中并没有 int、float、double、long这样的原始类型，取而代之的是它们对应的引用类型包装类Int、Float、Double、Long。

除了以上代表数值的类型，还有布尔（Boolean）、字符（Char）、字符串（String）及数组（Array）。这让 Kotlin 比起 Java 来更加接近纯面向对象的设计——一切皆对象。

但这么说其实也是不够严谨的。以Int为例，虽然它可以像Integer一样提供额外的操作函数，但这两个类型在底层实现上存在差异。Kotlin 中的 Int 在 JVM 中实际以 int 存储（对应字节码类型为I）但是，作为一个“ 包装类型”，编译后应该装箱才对，难道，Kotlin 不会自动装箱？

我们可以简单地认为：

• Kotlin中的 Int 类型等同于 int；
• Kotlin中的 Int? 等同于 Integer。

Int作为一种小技巧，让Int看起来是引用类型，这在语法上让 Kotlin 更接近纯面向对象语言。

数组类型

val funList = arrayOf() // 声明长度为0的数组
val funList = arrayOf(n1, n2, n3, ..., nt) // 声明并初始化长度为t的数组 

Kotlin中 Array 并不是一种原生的数据结构，而是一种Array类，甚至我们可以将 Kotlin 中的Array视作集合类的一部分。

由于 Smart Casts，编译器能够隐式推断出funList元素类型。当然，我们也可以手动指定类型

val funList = arrayOf<T>(n1, n2, n3..., nt)

在 Kotlin 中，还为原始类型额外引入了一些实用的类：IntArray、CharArray、ShortArray等，分别对应 Java 中的int[]、char[]、short[]等。

val x = intArrayOf(1,2,3) 

注意：IntArray等并不是Array的子类，所以用两者创建的相同值的对象，并不是相同对象。

由于 Kotlin 对原始类型有特殊的优化（主要体现在避免了自动装箱带来的开销），所以我们建议优先使用原始类型数组。

泛型

class SmartList<T> : ArrayList<T>() {
    fun find(t: T): T? {
        val index = super.indexOf(t)
        return if (index >= 0) super.get(index) else null
    }

    fun main(args: Array<String>) {
        val smartList = SmartList<String>()
        smartList.add("one")
        println(smartList.find("one")) // 输出: one
        println(smartList.find("two").isNullOrEmpty()) // 输出: true
    }
}

由于扩展函数支持泛型，可以利用扩展函数实现上面的功能：

fun <T> ArrayList<T>.find(t: T): T? {
    val index = this.indexOf(t)
    return if (index >= 0) this.get(index) else null
}

fun main(args: Array<String>) {
    val arrayList = ArrayList<String>()
    arrayList.add("one")
    println(arrayList.find("one")) // 输出: one
    println(arrayList.find("two").isNullOrEmpty()) // 输出: true
}

类型约束：设定类型上界

class FruitPlate<T : Fruit>(val t: T)
class Noodles(weight: Double) // 面条类
val applePlate = FruitPlate<Apple>(Apple(100.0)) // 允许 
val applePlate = FruitPlate(Apple(100.0)) // 允许, 同上简化写法
val noodlesPlate = FruitPlate<Noodles>(Noodles(200.0)) // 不允许

支持可空T类型：

class FruitPlate<T: Fruit?>(val t:T) 
val fruitPlate = FruitPlate(null) 

多个泛型条件约束：

interface Ground {}
class Watermelon(weight: Double) : Fruit(weight), Ground

fun <T> cut(t: T) where T : Fruit, T : Ground {
    print("You can cut me.")
}

cut(Watermelon(3.0)) // 允许
cut(Apple(2.0)) // 不允许

我们可以通过where关键字来实现这种需求，它可以实现对泛型参数类型添加多个约束条件，比如这个例子中要求被切的东西是一种水果，而且必须是长在地上的水果。

Java 为什么无法声明一个泛型数组

我们先来看一个简单的例子，Apple是Fruit的子类，思考下Apple[]和Fruit[]，以及List和List是什么关系呢？

Apple[] appleArray = new Apple[10];
Fruit[] fruitArray = appleArray; // 允许
fruitArray[0] = new Banana(0.5); // 编译通过，运行报 ArrayStoreException

List<Apple> appleList = new ArrayList<Apple>();
List<Fruit> fruitList = appleList; // 不允许

我们发现一个奇怪的现象，Apple[]类型的值可以赋值给Fruit[]类型的值，而且还可以将一个Banana对象添加到fruitArray，编译器能通过。作为对比，List类型的值则在一开始就禁止被赋值为List类型的值，这其中到底有什么不同呢？

其实这里涉及一个关键点，数组是协变的，而List是不变的。简单来说，就是 Object[] 是所有对象数组的父类，而 List