Kotlin核心编程 第五章类型系统

null引用

对于空指针异常，当前java已经有了如下处理：
1函数内对于无效值，更倾向于抛异常处理；
2采用@NotNull/@Nullable标注，明确参数是否可空，避免非法null值进一步传递；
3使用专门的optional对象对可能为null的变量进行装箱。这类对象必须拆箱后才能参与运算。
*java8新增了Optional类

Kotlin的可空类型：?.
*由于null只能被存储在java的引用类型的变量中，所以在kotlin中基本数据的可空版本都会使用该类型的包装形式。同样，如果你用基本数据类型作为泛型类的类型参数，Kotlin同样会使用该类型的包装形式。
Elvis操作符：?:
非空断言!!.

上面说到过解决npe一般有三种方式：
1用try catch捕获异常
2用Optional类似的类型来包装
3用@NotNull/@Nullable注解来标注

kotlin是：在方法参数上标注了@Nullable,在实现上，依旧采用了if..else来对可空情况进行判断。兼容了java老版本，实现与java100%互转，性能上达到最佳。

如需抛出异常则为：

val s :Student?= null
println(s?.glas?:throw NullPointerException("some thing null"))

类型检查 is

    if(obj is String){
        pringln(obj.lenth)
    }

这里的obj类型为Any,是kotlin的智能转换（Smart Casts）帮我们省略了一些工作。
Kotlin与其他面向对象语言一样，无法直接将父类型转为子类型，当需要类型转换时，利用as操作符来实现。
*Kotlin还提供了as?操作符

5.3比java更面向对象的设计

与Object作为java类层级结构的顶层类似，Any类型时Kotlin中所有非空类型（如String，Int）的超类。

20200215120301780.png

与Object作为Java类层级结构的顶层类似，Any类型是 Kotlin 中所有非空类型的超类。
对于Kotlin 来说，如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如果定义了父类型，那么该父类型是该类的直接父类型，但是新类型的最终根类型为Any。
Kotlin的Type Checker强制检查了父子关系。例如，你可以将子类型值存储到父类型变量中。但是不能将父类型值存储到子类型中。
Kotlin把Java方法参数和返回类型中用到的Object类型看作Any(更准确的说是“平台类型”)。当在Kotlin函数中使用Any时，它会编译成Java字节码中的Object。

Any? 所有类型的根类型

Any是所有非空类型的根类型，Any?才是所有类型（可空和非空类型）的根类型。

Any? 与Any??
如果Any?是Any的父类型，那么Any?? 是否又是Any？的父类型，如果成立，是否意味着就没有所谓的所有类型的根类型了？
在Kotlin 中，可空类型可以看作是所谓的Union Type，近似于数学中的并集。如果用类型的并集来表示Any？可写为Any U Null。
相应的Any??就可以表示为Any U Null U Null，等价于Any U Null，即Any??等价于Any？。因此，说Any?是所有类型的根类型是没有问题的。

Nothing与Nothing?
Nothing是没有实例的类型。Nothing类型的表达式不会产生任何值。需要注意的是：任何返回值为Nothing的表达式之后的语句都是无法执行的。Kotlin中retrun、thorw等（流程控制中与跳转相关的表达式）返回值都为Nothing。
Nothing对应的Nothing?，可以从字面上解释为：可空的空。与Any、Any?类似，所以Nothing?是Nothing的父类型，所以Nothing处于Kotlin类型层级结构的最低层。它只能包含一个值：null，本质上与null没有区别。所以可以使用null作为可空类型的值。

自动装箱与拆箱

Koltin中没有int、double、float、long等基本数据类型，取而代之的是引用类型包装类Int、Float、Double、Long。
除了代表数值的类型，还有布尔（Boolean）、字符（Char）、字符串（String）及数组（Arry）。
但是只能说Kotlin比Java更接近纯面向对象的设计。
因为：

Kotlin代码

val x1:Int = 10
val x2:Int? =12

转Java代码

public final class TestIntDemoKt {
   private static final int x1 = 10;
   @Nullable
   private static final Integer x2 = 12;
 
   public static final int getX1() {
      return x1;
   }
 
   @Nullable
   public static final Integer getX2() {
      return x2;
   }
}

对应的字节码
BIPUSH 10
 PUTSTATIC com/example/kotlindemo/anyclassdemo/TestIntDemoKt.x1 : I
 BIPUSH 12
 INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;

观察上面代码可以发现，Koltin中的Int在JVM中实际以int存储（对应字节码类型是I）
所以我们可以简单的认为：
Kotlin中Int类型等同于int。
Kotlin中Int?等同于Integer。

“新“的数组类型

Kotlin中数组的创建：

val funList0 = arrayOf()//长度为0的数组
val funList= arrayOf(1,2,3) //初始化长度为3的数组

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

由于Smart Casts，编译器能够隐式推断出 funList元素类型。
在Kotlin中，还有一些实用的类，IntArray、CharArray、ShortArray等，分别对应Java中的int[]、char[]、short[]等。

val intArray = intArrayOf(1,2)

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

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

5.4泛型：让类型更加安全

泛型是一种编译时的安全检测机制，它允许在定义类、接口、方法时使用类型参数，声明的类型参数在使用时用具体的类型来替换。
众所周知，Java 1.5引入泛型。那么我们来思考一个问题，为什么Java一开始没有引入泛型，而1.5版本却引入泛型？先来看一个场景：

List stringList = new ArrayList();
stringList.add(new Double(2.0));
String str = (String)stringList.get(0);
执行结果：
>>> java.lang.ClassCastException:
 java.lang.Double cannot be cast to java.lang.String
    at javat.Rectangle.main(Rectangle.java:29)

因为ArrayList底层是用一个Object类型的数组实现的，这种实现虽然能让ArrayList变得更通用，但也会带来弊端。比如上面例子中，我们不小心向原本应作为String类型的List中添加了一个Double类型的对象，理想的情况下编译器应该能够提示错误，但事实上这段代码能编译通过，在运行时却会报错。这是一个非常糟糕的体验，我们真正需要的是在代码编译的时候就能发现错误，而不是让错误的代码发布到生产环境中。这便是泛型诞生的一个重要的原因。有了泛型后，我们可以这么做：

List stringList = new ArrayList();
        stringList.add(new  Double(2.0));  //编译时报错，add(java.lang.String)无法适配add
            (java.lang.Double)

利用泛型代码在编译时期就能发现错误，防止在真正运行的时候出现ClassCastException。当然，泛型除了能帮助我们在编译时期进行类型检查外，还有很多其他好处，比如自动类型转换。
继续来看第一段代码，在获取List中的值的时候，我们进行了以下操作：

 String str = (String)stringList.get(0);

是不是感觉异常的烦琐，明明知道里面存的是String类型的值，取值的时候还要进行类型强制转换。但有了泛型之后，就可以利用下面这种方式实现：

        List stringList = new ArrayList();
        stringList.add("test");
        String str = stringList.get(0);

有了泛型之后，不仅在编译的时候能进行类型检查，在运行时还会自动进行类型转换。而且通过引入泛型，增强上述功能的同时并没有增加代码的冗余性。比如我们无须为声明一个类型安全的List而去创建StringList、DoubleList等类，只需在声明List的同时指定参数类型即可。
总的来说，泛型有以下几点优势：
类型检查，能在编译时就帮你检查出错误；
更加语义化，比如我们声明一个List，便可以知道里面存储的是String对象，而不是其他对象；
自动类型转换，获取数据时不需要进行类型强制转换；
能写出更加通用化的代码。

如何在Kotlin中使用泛型

假设现在我们有一个需求，定义一个find方法，传入一个对象，若列表中存在该对象，则返回该对象，不存在则返回空。由于原有的集合类不存在这个方法，所以可以定义一个新的集合类，同样也要声明泛型。我们可以这么做：

class SmartList : ArrayList () {
    fun find(t: T): T? {
        val index = super.indexOf(t)
        return if (index >= 0) super.get(index) else null
    }
}
fun main(args: Array) {
    val smartList = SmartList()
    smartList.add("one")
    println(smartList.find("one"))//输出one
    println(smartList.find("two").isNullOrEmpty())//输出true
}

发现，Kotlin定义泛型类的方式与我们在Java中所看到的类似。另外泛型类同样还可以继承另一个类，这样我们就可以使用ArrayList中的属性和方法了。
当然，除了定义一个新的泛型集合类外，我们还可以利用扩展函数来实现这种需求。由于扩展函数支持泛型的情况，所以我们可以这么做：

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

    val arrayList = ArrayList()
    arrayList.add("one")
    println(arrayList.find("one"))//输出one
    println(arrayList.find("two").isNullOrEmpty())//输出true
}

利用扩展函数这种方式也非常简洁，所以，当你只是需要对一个集合扩展功能的时候，使用扩展函数非常合适。

使用泛型时是否需要主动指定类型？
在Kotlin中，以下的方式不被允许：

val arrayList = ArrayList()

而在Java中却可以这么做，这主要是因为泛型是Java 1.5版本才引入的，而集合类在Java早期版本中就已经有了。各种系统中已经存在大量的类似代码：

List list = new ArrayList();

所以，为了保证兼容老版本的代码，Java允许声明没有具体类型参数的泛型类。而Kotlin是基于Java 6版本的，一开始就有泛型，不存在需要兼容老版本代码的问题。所以，当你声明一个空列表时，Kotlin需要你显式地声明具体的类型参数。当然，因为Kotlin具有类型推导的能力，所以以下这种方式也是可行的：

val arrayList = arrayListOf("one", "two")

总的来说，使用泛型可以让我们的代码变得更加通用化，更加灵活。但有时过于通用灵活并不是一个好的选择，比如现在我们创建一个类型，只允许添加指定类型的对象。接下来我们就来看看如何在Kotlin中约束类型参数。

类型约束：设定类型上界
假设现在有一个盘子，他可以放任何东西，在Kotlin中我们可以这么做

class Plate(val t :T)

突然你想把自己的盘子归归类，一些只放水果，一些放菜，我们定义Fruit类并声明Apple和Banana类来继承他

open class Fruit(val weight:Double)
class Apple(weight:Double):Fruit(weight)
class Banana(weight:Double):Fruit(weight)

在定义一个水果盘子

class FruitPlate(val t :T)

这里的T只能是Fruit类及其子类型。

val applePlate = FruitPlate(Apple(100.0))
val applePlate = FruitPlate(Apple(100.0))//简化写法

java中通过extends关键字，而kotlin使用：

class FruitPlate{}

通过where关键字,实现对泛型参数类型添加多个约束条件。
假设一把刀只能切在地上的水果：

fun main() {
    cut(Watermelon(3.0))
    cut(Apple(2.0))//Type mismatch: inferred type is Apple but Ground was expected
}

interface Ground{}

open class Fruit(val weight:Double)

class Apple(weight:Double):Fruit(weight)
class Watermelon(weight:Double):Fruit(weight),Ground


fun  cut(t:T) where T:Fruit,T:Ground{
    print("cut me")
}

5.5泛型的背后:类型擦除

Java为什么无法声明一个泛型数组（加入泛型后，运行时无法知道数组的类型，无法满足数组协变的原则）
我们先来看一个简单的例子，Apple是Fruit的子类，思考下Apple[]和Fruit[]，以及List和List是什么关系呢？

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

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

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