Kotlin-简约之美-基础篇（四）：类与继承

@[toc]

类的创建

与Java一样，Kotlin也是用class关键字声明类。

class User{}

Kotlin中一个类可以有一个主构造方法（primary constructor）和一个或多个次构造方法（ secondary constructors）。

主构造方法

主构造方法通过在类名后面添加constructor和参数实现：

class User{}

如果没有注解和可见的修饰符，constructor关键字可以省略：

class User private constructor(name: String) {}

• 初始化顺序
  类内部的init模块和变量的初始化顺序按照他们出现的顺序进行

fun main(args: Array<String>) {
    User("mao")
}

class User(name: String) {
    val firstProperty = "First property".also(::println)

    init {
        println("First initializer")
    }

    val secondProperty = "Second property".also(::println)

    init {
        println("Second initializer")
    }
}

输出：

• 成员变量和init模块在初始化时可直接使用主构造方法中的参数

First property
First initializer
Second property
Second initializer

次构造方法

• 次构造方法也使用constructor实现

class User {

    var name: String = ""

    constructor(name: String) {
        this.name = name
    }
}

• 当类声明了主构造方法，所有次构造方法必须直接或间接调用主构造方法

class User() {
    constructor(name: String) : this() {
        print("conconstructor")
    }

    constructor(name: String, age: Int) : this(name) {}
}

类中的变量初始化和init模块初始化都是主构造方法的一部分，所以都在次构造方法之前执行

fun main(args: Array<String>) {
    User("mao")
}

class User() {
    constructor(name: String) : this() {
        print("conconstructor")
    }
    
    var name = "property".also(::println)
    init{
        println("init")
    }
}

输出：

property
init
conconstructor

• 当一个类没有任何构造方法时，默认生成一个public类型的无参主构造方法，如果不希望这个默认构造方法存在，可以主动声明一个主构造方法

class User private constructor() {}

继承

Kotlin中的类默认是final类型的，想要被继承，得用“open”关键字修饰。

open class Shape {}

class Rectangle : Shape {}

子类的所有构造构造方法必须直接或间接调用一个父类的构造方法

open class Shape {
    constructor(name: String) {
        print(name)
    }
}

class Rectangle : Shape {
    constructor(name: String) : super(name) {}

    constructor(name: String, age: Int) : this(name) {}
}

成员方法重写

继承过程中，只有open修饰的方法才能被重写，重写时要用override修饰。
open特性也能被继承，想要断了open特性，只需用final修饰即可。

open class Shape {
    open fun method() {}
}

open class Rectangle : Shape() {
    override fun method() {}
}

class Square : Rectangle() {
    final override fun method() {}
}

成员变量重写

与方法重写相同，只有open修饰的变量才能被重写，open同样可以继承，也可以用final中断。
重写过程中，变量可由val类型变为var类型，反之则不行。

open class Shape {
    open val name: String = "Shape"
}

open class Rectangle : Shape() {
    override var name: String = "Rectangle"
}

class Square : Rectangle() {
    final override var name = "Square"
}

调用父类方法和变量

• 可通过“super”关键字调用父类的方法和成员变量

open class Shape {
    open val name: String = "Shape"
    open fun draw() {}
}

open class Rectangle : Shape() {
    override var name: String = super.name
    override fun draw() {
        super.draw()
    }
}

• 内部类调用外部类父类的方法
  使用“super@Outer”方式：

open class Sup {
    open fun method() { println("Sup.method") }
}

class Sub:Sup(){
    inner class Inner{
        fun test(){
            super@Sub.method()
        }
    }
}

• 当继承的类和接口当中出现相同的方法（方法名和参数都相同），通过类似泛型的方法明确调用哪个方法

interface Action {
    fun eat() {
        println("Action")
    }
}

open class Animal {
    open fun eat() {
        println("Animal")
    }
}

class Human() : Animal(), Action {
    override fun eat() {
        super<Action>.eat()
        super<Animal>.eat()
    }
}