[TOC] ## 子类和子类型 子类是继承的概念，如果B继承A，则B就是A的子类。**如果需要使用类型A的变量时，可以使用类型B的变量来代替，则此时类型B就是A的子类型**。子类与子类型是不同的，类中变量的替换原则只适合于子类型关系。一般情况下，编程语言只考虑了子类关系，子类说明是一个新类继承了父类，而**子类型则是强调了新类具有父类一样的行为，这个行为不一定是继承**。在本节我们将针对子类与子类型进行讲解。 为了讨论类型之间的关系，需要熟悉子类型这个术语。任何时候如果需要的是类型A 的值，你都能够使用类型B 的值（当作A 的值） ， 类型B 就称为类型A 的子类型。举例来说， Int 是Number 的子类型，但Int 不是Str ing 的子类型。这个定义还表明了任何类型都可以被认为是它自己的子类型，如图所示。  术语超类型是子类型的反义词。如果A 是B 的子类型，那么B 就是A 的超类型。为什么一个类型是否是另一个的子类型这么重要？编译器在每一次给变量赋值或者给函数传递实参的时候都要做这项检查。参考下面这个例子。  只有值的类型是变量类型的子类型时，才允许变量存储该值。例如，变量口的初始化器i 的类型Int 是变量的类型Number 的子类型，所以口的声明是合法的。只有当表达式的类型是函数参数的类型的子类型时，才允许把该表达式传给函数。这个例子中i 的类型Int 不是函数参数的类型String 的子类型，所以函数f 的调用会编译失败。 简单的情况下，子类型和子类本质上意味着一样的事物。例如， Int 类是Number 的子类，因此Int 类型是Nur由er 类型的子类型。如果一个类实现了一个接口，它的类型就是该接口类型的子类型： String 是CharSequence 的子类型。 可空类型提供了一个例子，说明子类型和子类不是同一个事物，如图所示。  一个非空类型是它的可空版本的子类型，但它们都对应着同一个类。你始终能在可空类型的变量中存储非空类型的值，但反过来却不行（ null 不是非空类型的变量可以接收的值）: ``` val s: String = "abc" val t: String? = s//这次赋值是合法的，因为String是String?的子类型 ``` 当我们开始涉及泛型类型时，子类型和子类之间的差异显得格外重要。前面一节的那个问题，把`List<String＞`类型的变量传给期望`List <Any>`的函数是否安全，现在可以使用子类型化术语来重新组织： `List<String＞`是`List <Any>`的子类型吗？你已经了解了为什么把`MutableList <String>`当成`MutableList<Any>`的子类型对待是不安全的。显然，反过来也是不成立的：`MutableList<Any>`肯定不是`MutableList<String>`的子类型。 一个泛型类一一例如， MutableList 一一如果对于任意两种类型A 和B，`MutableList<A>`既不是`MutableList<B>`的子类型也不是它的超类型，它就被称为在该类型参数上是不变型的。Java中所有的类都是不变型的（尽管那些类具体的使用可以标记成可变型的，稍后你就会看到） 。 在前一节中，你见过一个这样一个类， List ，对它来说，子类型化规则不一样。Kotlin 中的List 接口表示的是只读集合。如果A 是B 的子类型，那么`List <A>`就是`List<B>`的子类型。这样的类或者接口被称为协变的。 ### 继承与子类型 * 如果B类是A类的子类，则B就是A的子类型。当新类的行为与父类完全一致，在任何使用父类的场合，新类都表现一致的行为，此时可以使用继承。 接下来我们通过一个动物的案例来描述子类型。假如有两个实体类，分别是Animal（动物）、Cat（猫），这两个类为继承关系，具体代码如下所示。 ``` open class Animal { fun bathe() { println("洗澡...") } } class Cat : Animal() fun work(animal: Animal): Unit { animal.bathe() } fun main(args: Array<String>) { var cat = Cat() work(cat) } ``` 运行结果： ``` 洗澡… ``` 上述代码中，创建了两个类，分别是Animal类与Cat类，其中Cat类继承Animal类，**Cat类是Animal类的子类**。在第12行代码中可以看到，**调用work()方法时，该方法中需要传递的参数类型是Animal，实际传递到该方法中的参数类型是Cat类型。这段代码不仅可以编译通过，而且可以运行成功，这说明Cat类是Animal类的子类型**。 * 如果B类不是A类的子类型，则不可以代替A类做一些事情。接下来让我们通过一个案例来看一下B类不是A类的子类型时的情况，具体代码如下所示。 ``` fun output(number: Number): Unit { println(number) } fun main(args: Array<String>) { var i = 1 output(i) var str = "Hello" // output(str) // 编译器会提示错误 } ``` 上述代码中，output()方法中需要传递的是Number类型的数据，第6行中向output ()方法中传递了一个Int类型的变量i，编译通过。第8行中向output()方法中传递了一个String类型的变量str，此时编译器提示编译错误。出现以上这些情况是**因为Int类型是Number类型的子类型，String类型不是Number类型的子类型**。 ### 接口与子类型 * 如果B类实现了接口A，则B类就是接口A的子类型，例如[String](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html)类实现了CharSequence接口，String类就是接口CharSequence的子类型。 ~~~ class String : Comparable<String>, CharSequence interface CharSequence ~~~ 接下来我们通过一个案例来说明String类是接口CharSequence的子类型，具体代码如下所示。 ``` fun export(str: CharSequence): Unit { println(str) } fun main(args: Array<String>) { val str:String= "Hello Kotlin" export(str) } ``` 运行结果： ``` Hello Kotlin ``` 上述代码中，export ()方法中传递的参数类型是CharSequence，在第6行调用这个方法时，传递的参数是String类型的数据，编译器没有报错，并且程序运行成功，这就说明**当一个类实现了一个接口，则这个类就是这个接口的子类型**。 ### 可空类型的子类型 **非空类型String是可空类型String?的子类型**。接下来我们通过一个案例来验证一下这个结论，具体代码如下所示。 ``` fun print(str: String?): Unit { println(str) } fun main(args: Array<String>) { var str1: String = "非空" var str2: String? = null print(str1) print(str2) } ``` 运行结果： ``` 非空 null ``` 上述代码中，print()方法中需要传递可空参数，但是在main()方法中调用print()方法时，传递了非空参数和可空参数，编译器没有报错并且程序可以运行成功。这就说明**String类型是String？类型的子类型**，也就是**非空类型是可空类型的子类型**。 如果将上述代码中的print()方法中的参数类型String?改为String，其余代码不变，则会在调用print()方法时报错，这个错误提示是类型不匹配，这就说明了String?不是String的子类型，也就是**可空类型不是非空类型的子类型**。 >[success]**脚下留心：B是A的子类型，但Xxx＜B＞不是Xxx＜A＞的子类型** 如果B类是A类的子类型，但Xxx＜B＞不是Xxx＜A＞的子类型，这里的**Xxx表示的是任意一个类或者接口**，例如可以是List接口、PetShop类等。如果Cat类是Animal类的子类，但List＜Cat＞并不是List＜Animal＞的子类型，PetShop＜Cat＞也不是PetShop＜Animal＞的子类型。 接下来我们通过一个给宠物洗澡的案例来说明如果B类是A类的子类型，但**Xxx＜B＞不是Xxx＜A＞的子类型**。具体代码如下所示。 ``` open class Animal { fun bathe() { println("开开心心地洗澡...") } } class Cat : Animal() //猫类 class PetShop<T : Animal>(var animals: List<T>)//宠物店类 //帮所有的宠物洗澡 fun batheAll(petShop: PetShop<Animal>) { for (animal: Animal in petShop.animals) { animal.bathe() //开始洗澡 } } fun main(args: Array<String>) { val cat1 = Cat() //第1只猫 val cat2 = Cat() //第2只猫 val animals = listOf<Cat>(cat1, cat2) //宠物装入一个集合 val petShop=PetShop<Cat>(animals) //将宠物送到宠物店 // batheAll(petShop) 编译器报错 } ``` 上述代码中，创建了一个Cat类继承Animal类，从第18行代码可以看出，Cat类可以代替Animal类，Cat类是Animal类的子类型，但是在第19行中，batheAll()方法中需要传递的是PetShop＜Animal＞类型的数据，实际传递的是PetShop＜Cat＞类型的数据，因此编译器在编译时就报错了，提示“`Type mismatch: inferred type is PetShop<Cat> but PetShop<Animal> was expected`”，也就是“类型不匹配”，因此可以说明PetShop＜Cat＞不是PetShop＜Animal＞的子类型。即**B类是A类的子类型，但Xxx＜B＞不是Xxx＜A＞的子类型**。