接口与抽象类的区别

同样在Kotlin中也有接口的概念，与Java不同的是，Kotlin中的接口可以定义变量，但是不能为变量提供构造函数，也可以实现函数体，如果没有实现的函数，默认抽象，不需要使用abstract来定义。

而抽象类中，可以为定义的变量提供构造函数进行赋值，而如果没有赋值的变量需要使用abstract来定义，而没有实现的函数也需要使用abstract来定义

接口

Kotlin中的接口可以定义变量，也允许实现函数体。但是不允许有构造函数，并且抽象函数也不需要使用abstract关键字定义。

但是在实现接口的子类中必须使用override来覆盖接口中所定义的变量以及抽象函数。而提供了get方法的变量，也就不需要子类实现了。

interface IPerson {
    val mName: String
    var mAge: Int
    val mDump: String
        get() = "$mName...$mAge"

    fun print() {
        Log.e("IPerson", "mName:$mName...mAge:$mAge")
    }

    fun walk()
}

子类实现：

class Child(name: String, age: Int = 18) : IPerson {
    // 必须要重载接口中定义的变量
    override var mName = name
    override var mAge = age

    override fun walk() {
        Log.e("Child", "Child Walk called:$mName...$mAge")
    }
}

抽象类

抽象类中定义的变量如果没有在构造函数中赋值的话，则需要使用abstract定义，而函数也一样，如果没有实现，则需要使用abstract来定义

abstract class AbsPerson(name: String) {
    var mName: String = name
    abstract var mAge: Int

    fun print() {
        Log.e("IPerson", "mName:$mName...mAge:$mAge")
    }

    abstract fun walk()
}

子类实现：

open class Child(name: String, age: Int = 18) : AbsPerson(name) {
    override var mAge = age

    override fun walk() {
        Log.e("Child", "Child Walk called:$mName...$mAge")
    }
}

继承

在Kotlin中，如果没有定义abstract的抽象来定义类或者函数的话，那么就需要使用open关键字来定义才允许让子类继承或者重载函数

因为如果没有使用open定义的话，则默认会添加final标志位，不可重写。

open class Child(name: String, age: Int = 18) : AbsPerson(name) {

    override var mAge = age

    override fun walk() {
        Log.e("Child", "Child Walk called:$mName...$mAge")
    }

    protected open fun run() {
        Log.e("Child", "Child can't Run:$mName...$mAge")
    }
}

子类实现

class Teenager(name: String) : Child(name) {

    override fun run() {
        super.run()
        Log.e("Teenager", "Teenager can run:$mName...$mAge")
    }
}