Kotlin 学习——类和继承

    在 Kotlin 中，类使用 class 关键字来声明，类声明一般由类名、类头（指定了类型的参数、主构造方法）以及使用 {} 包起来的类体，类体可为空：

// 无构造方法的类
class Demo{
    
}

     当只有一个构造方法时，一般写在类名后面，多个构造方法时，在类名后面的构造方法为主构造方法，如果主构造方法没有任何注解或者可见性修饰符，可以省略 constructor 关键字：

class Demo constructor(name:String) {

}
// 或者
class Demo (name:String) {

}

    主构造方法不能包含任何的代码，初始化的代码要放到 init{} 代码块中，如果有多个 init{} 代码块，按顺序执行：

class Demo (name:String) {

    init {
        println("$name A")
    }
    init {
        println("$name B")
    }
}
// Kotlin 中 main() 默认是新建立一个文件专门跑 main() 方法
fun main(args: Array<String>) {
    Demo("name")
}

    结果：

   

     如果有主构造方法在类名后面，新的构造方法需要委托给主构造方法，可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可：

class Demo (name:String) {
    constructor(name: String,age:Int):this(name){
        println("name:$name,age:$age")
    }
}
// Kotlin 中 main() 默认是新建立一个文件专门跑 main() 方法
fun main(args: Array<String>) {
    Demo("李四",20)
}

    结果：

    主构造方法是默认 public 的，如果你想你的构造方法私有化，只需要在 constructor 前面设置 private：

• 继承：在 Kotlin 中也支持继承，和 Java 中每一个类都继承了 Object 类一样，Kotlin 中每一个类都有一个共同的超类：Any（Any 并不是 java.lang.Object。尤其是，它除了 equals()、hashCode()和 toString()外没有任何成员）

    在 Kotlin 中，要想类可以被继承，需要使用 open 关键字，该关键字与 Java 中的 final 相反，它允许该类可以被继承，可以说，Kotlin 中的类默认是 final 的：

open class Father(lastName:String)

class Son(lastName: String):Father(lastName)

    当父类有主构造参数时，子类必须要有主构造参数：

open class Father(lastName:String){
    init {
        println("lastName of Father:$lastName")
    }
    
    fun show(){
        println("Hello")
    }
}

class Son(lastName: String):Father(lastName){

    init {
        println("lastName of Son:$lastName")
    }
}

fun main(args: Array<String>) {
    Son("HHHH").show()
}

    结果：

    当父类没有主构造方法时，有次构造方法，子类需要使用 super 关键字：

open class Father{
    constructor(lastName:String){
        println("lastName of Father:$lastName")
    }

    fun show(){
        println("Hello")
    }
}

class Son:Father{
    constructor(lastName: String):super(lastName){
        println("lastName of Son:$lastName")
    }
}

fun main(args: Array<String>) {
    Son("HHHH").show()
}

    结果：

• 方法覆盖：而 Kotlin 中方法覆盖时也是一样，需要对父类方法使用 open 方法允许覆盖，然后在子类中对要覆盖的方式使用 override 关键字。

open class Father{
    open fun show(){
        println("I'm Father !")
    }
}

class Son: Father() {
    override fun show() {
        println("I'm Son !")
    }
}
fun main(args: Array<String>) {
    Father().show()
    Son().show()
}

    结果：

    因为 override 关键字就表示该方法是可以覆盖的，要想它不能被覆盖，就需要添加一个 final 关键字：

    这样的话 show() 方法就不能被覆盖了。

• 属性覆盖：和方法覆盖类似，父类属性使用 open 关键字，子类属性使用 override 关键字，并且它们必须具备有兼容的类型：

open class Father {
    open val name = "Father"
}
class Son:Father(){
    override val name = "Son"
}
fun main(args: Array<String>) {
    println(Father().name)
    println(Son().name)
}

    结果：

    你也可以用一个 var 属性覆盖一个 val 属性，但反之则不行。这是允许的，因为一个 val 属性本质上声明了一个 getter() 方法，而将其覆盖为 var 只是在子类中额外声明一个 setter() 方法。

• 子类初始化顺序：

open class Father(lastName:String) {
    val a = lastName.length

    open val name = "Father"
    init {
        println("$name:$lastName + $a")
    }
}
class Son(lastName: String):Father(lastName){
    override val name = "Son"
    init {
        println("${super.name}:$lastName")
    }
    init {
        println("$name:$lastName")
    }
}
fun main(args: Array<String>) {
    Son("张")
}

    结果：

    由结构可以看到：会先初始化父类，在父类的构造函数执行时，其非 open 属性也被初始化，而 open 属性未被初始化，所有会出现 null:张 + 1，接着才会初始化父类的 open 属性，所有子类就可以使用了，接着会初始化子类的构造方法。所以当我们设计一个父类时，应该避免在构造函数、属性初始化器以及 init 块中使用 open 成员。

• 调用父类方法：大家都知道 Java 中的 super 关键字，可以使用 super 关键字调用父类的属性和方法，在 Kotlin 中也是一样的：

open class Father{
    open fun show(){
        println("Father")
    }
}

open class Son:Father(){
    override fun show() {
        super.show()
        println("Son")
    }
}
fun main(args: Array<String>) {
    Son().show()
}

    结果：

    而在 Kotlin 的内部类中，可以使用 @ClassA.x() 来调用 ClassA 的父类的 x() 方法：

open class Father{
    open fun show(){
        println("Father")
    }
}

open class Son:Father(){
    override fun show() {
        super.show()
        println("Son")
    }
    inner class GrandSon{
        fun g(){
            super@Son.show()
        }
    }
}
class GrandSon:Son(){
    override fun show() {
        super.show()
        println("Son")
    }
    inner class GrandSon1{
        fun g(){
            super@GrandSon.show()
        }
    }
}

fun main(args: Array<String>) {
    Son().show()
    println("Son 的内部类：")
    Son().GrandSon().g()
    println("GrandSon 的内部类：")
    GrandSon().GrandSon1().g()
}

    结果：

• 覆盖原则：当一个类继承多个父类（只能多继承接口），如果父类中有一样的属性或者方法时，使用 super 要怎么判断调用哪一个父类的属性和方法呢？这个时候就需要使用 super<Father> 来判断使用哪一个父类的属性和方法：

open class Father{
    open fun show(){
        println("I'm Father")
    }
}
// 接口是默认 open 的
interface Mother{
    // 接口的方法也是默认 open 的
    fun show(){
        println("I'm Mother")
    }
}
// 和 Java 一样，Kotlin 的类只能继承一个，接口可以继承多个
class Son:Father(),Mother{
    override fun show() {
        super<Father>.show()
        super<Mother>.show()
    }
}

fun main(args: Array<String>) {
    Son().show()
}

    结果：

• 抽象类：在 Kotlin 中的类和某些成员可以声明为 abstract，抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open 关键字来标注一个抽象类或者函数。

abstract class Father{
    abstract fun show()
}

 class Son:Father(){
    override fun show() {
        println("hhhh")
    }
}

fun main(args: Array<String>) {
    Son().show()
}

    结果：

• 伴生对象：伴生对象有点类似于 Java 中被 static 标注的属性和方法，不用创建类实例，直接可以使用的属性和方法，伴生对象使用 companion object {} 关键字，然后直接使用类名调用属性或方法：

class Father{
    companion object {
        fun show(){
            println("Hello")
        }
    }
}

fun main(args: Array<String>) {
    Father.show()
}

    结果：