Kotlin——类的继承、解构声明和泛型

引言

通过前面几篇文章大致把Kotlin 语言的基本体系结构浏览了一遍

一、类的继承

与Java普通类 类似万物基于Object，Kotlin普通类也基于Any，所有的类都默认继承Any。Any默认也提供了三个函数：equals()、toString()、hashCode()，但Any 不是Object，Any类中只有这三个成员。与Java 不同，Kotlin的类默认是不可被继承的final 类型，如果想要作为基类被继承必须使用open 关键字修饰（抽象类也可被继承）。Kotlin中实现接口和继承都是使用关键字符冒号 ：（子类 : 基类1，基类2）

1、子类对于构造函数的处理

1.1、当子类有主构造函数

如果子类有主构造函数， 则基类必须在主构造函数中立即初始化。

open class People(var name : String, var age : Int){// 基类

}

class Student(name : String, age : Int, var no : String) : People(name, age) {

}

// 测试
fun inherit() {
    val s =  Student("CrazyMo_", 2, "200912301052", 89)
    println("姓名： ${s.name}")
    println("年龄： ${s.age}")
    println("学号： ${s.no}")
}
//结果
学生名： CrazyMo_
年龄： 2
学生号： 200912301052

1.2、当子类没有主构造函数

如果子类没有主构造函数，则必须在每一个次要构造函数或代理另一个构造函数中用 super 关键字初始化基类。初始化基类时，可以使用super来调用基类的不同构造函数。

//用户基类
open class People(name:String){
    //次要构造函数
    constructor(name:String,age:Int):this(name){
        println("基类次要构造函数")
    }
}

/**子类继承 People类**/
class Student:People{

    /**次要构造函数**/
    constructor(name:String,age:Int,no:String):super(name,age){
        println("继承类次要构造函数")
        println("学生名： ${name}")
        println("年龄： ${age}")
        println("学生号： ${no}")

    }
}

2、方法的覆盖

基类中，使用fun声明函数时（默认为final修饰）不能被子类重写。如果要允许子类重写该函数，就要使用 open 关键字修饰, 子类重写方法使用 override 关键字。

open class People(var name : String, var age : Int){// 基类
    open fun show(){
        println("基类中的show函数")
    }
}

class Student(name : String, age : Int, var no : String, var score : Int) : People(name, age) {
    //子类中的方法签名必须和父类的一样
    override fun show(){
        println("子类中的show函数")
    }
}

若有多个相同的方法（比如同时继承或者实现自其他多个类），则必须要重写该方法并使用super范型去选择性地调用父类的实现。

open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}

class C() : A() , B{
    override fun f() {
        super.f()//调用 A.f()
        super.f()//调用 B.f()
    }
}

fun main(args: Array) {
    val c =  C()
    c.f();
}

3、属性的覆盖

Kotlin默认的属性和函数一样也是不可被覆盖的，都需要使用open 来显示注明可被覆盖，属性覆盖使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被覆盖，可以使用var 属性来覆盖一个 val 属性，但是反过来不行。（因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法）

open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}

还可以在主构造函数中使用 override 关键字作为属性声明的一部分

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}

4、继承需遵守的规则

• 如果一个类从其直接的超类继承同一个成员的许多实现，它必须覆盖该成员并提供自己的实现
• 要表示从其继承的实现的超类型，我们在尖括号中使用超类型名称的超级限定 如 super

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // interface members are 'open' by default
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super.f() // call to A.f()
        super.f() // call to B.f()
    }
}

二、解构声明Destructuring Declarations

所谓解构声明就是把对象属性分解并映射到对应的变量中，具体语法形式就像是把对象赋值到一组自定义的变量集中（变量名称不一定要对应对象的属性名、数量只要不大于原对象属性的个数且自Kotlin1.1起还可以使用下划线⽤于未使⽤的变量即可），Kotlin自动会根据变量定义的顺序一一映射。

1、对象的解构声明

data class User(val name: String, val age: Int)

val user = User(name = "CrazyMO_", age = 100)
var (name2,age2) = user//这样的语法就是解构声明
//var (_,age2) = user//下划线来替代不想要的属性
println("解构出来的name:"+name2+"解构出来的age:"+ age2)

对于解构声明会被编译成componentN()

var name2 = user.component1()
val age2= user.component2()

其中的 component1() 和 component2() 函数是在 Kotlin 中⼴泛使⽤的约定原则 的另⼀个例⼦。实际上任何表达式都可以出现在解构声明的右侧，只要可以对它可以调⽤所需数量的 componentN 函数（数据类、for循环系统已经提供了对应的扩展）即可。所以可以有 component3() 和 component4() 等等。请注意componentN() 函数需要⽤ operator 关键字标记，以允许在解构声明中使⽤。这个特性背后的逻辑是非常强大的，比如解构声明也可以⽤在 for-循环中

//解构声明也可以⽤在 for-循环中：当你写
for ((a, b) in collection) { …… }

在很多情况下可以帮助我们简化代码。再比如集合Map类含有一些扩展函数的实现，允许它在迭代时使用key和value

for ((key, value) in map) {
    println("map", "key:$key, value:$value")
}

变量 key 和 value的值取⾃对集合中的元素上调⽤ component1() 和 component2() 的返回值，为使其能⽤解构声明，事实上标准库也是提供了这样的扩展

• 通过提供⼀个 iterator() 函数将映射表⽰为⼀个值的序列
• 通过提供函数 component1() 和 component2()来将每个元素呈现为⼀对。

operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> = entrySet().iterator()

operator fun <K, V> Map.Entry<K, V>.component1() = getKey()

operator fun <K, V> Map.Entry<K, V>.component2() = getValue()

因此你可以在 for-循环中对映射（以及数据类实例的集合等）⾃由使⽤解构声明。

2、Lambda表达式的解构声明

Kotlin1.11起，你可以对 lambda 表达式参数使⽤解构声明语法，如果 lambda 表达式具有 Pair 类型（或者 Map.Entry 或任何其他具有相应 componentN 函数的类型）的参数，那么可以通过将它们放在括号中来引⼊多个新参数来取代单个参数：

map.mapValues { entry -> "${entry.value}!" }

map.mapValues { (key, value) -> "$value!" }

声明⼀个解构对来取代单个参数之间的区别：

{ a //-> …… } // ⼀个参数
{ a, b //-> …… } // 两个参数
{ (a, b) //-> …… } // ⼀个解构对
{ (a, b), c //-> …… } // ⼀个解构对以及其他参数

如果解构的参数中的⼀个组件未使⽤，那么可以将其替换为下划线，以避免编造其名称：

map.mapValues { (_, value) -> "$value!" }

你可以指定整个解构的参数的类型或者分别指定特定组件的类型：

map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" }
map.mapValues { (_, value: String) -> "$value!" }

三、泛型Generics

所谓泛型，即 “参数化类型”，将类型参数化，可以用在类，接口，方法上为类型安全提供保证，消除类型强转的烦恼。

1、泛型的定义

声明一个泛型

class Box<T>(t: T) {
    val value = t
}

创建泛型类，通常需要提供具体的类型，但是如果类型参数可以推断出来，则类型参数可省（比如从构造函数的参数或者从其他途径）

val box: Box = Box(10)

val box2 = Box(10) // 10 具有类型 Int，所以编译器知道我们说的是 Box。

val box3= Box(null)//第三个对象接收一个null引用，那仍然还是需要指定它的类型，因为它不能去推断出来

当我们想限制上一个类中为非null类型，我们只需要这样定义泛型类T: Any

//你将看到t3现在会抛出一个错误。可null类型不再被允许了
class Box(t: T) {
    val value = t
}

同理我们严格限制到泛型类只能是某一类的子类，可以这样定义T: Xxxx，以只能是View 的子类为例

//只有是View 的子类才能使用这个泛型类
class MyView(t: T) {
    val value = t
}

在函数中使用泛型

fun <T> genericFun(item: T): List<T> {
    ...
}

2、型变Variance

我们都知道Java普通泛型是不型变的（即List 并不是 List