抽象類

一個類和它的一些成員可以宣告為abstract。類中抽象的成員沒有實現。需要注意的是，我們不需要用open顯式註解抽象類或函式。
我們可以用一個非抽象的open函式覆寫一個抽象的函式。

open class Base {
    open fun f() {

    }
}

abstract class Derived : Base() {
    override abstract fun f()
}

介面

Kotlin中的介面和Java 8中的類似。它們可以包含抽象方法的宣告，或者實現也可以。和抽象類的區別在於介面不能儲存狀態。它們可以具有屬性，但這些需要是抽象的或提供訪問器實現。
介面的定義使用關鍵字interface

interface MyInterface{
    fun bar()
    fun foo(){
        println("MyInterface.foo")
    }
}

實現介面

一個類或物件可以實現一個或多個介面。

class ChildOfInterface : MyInterface {
    override fun bar() {
        foo()
    }

    override fun foo() {
        super.foo()
        println("ChildOfInterface.foo"
 
)
    }

}

介面中的屬性

介面中是可以宣告屬性的。介面中的宣告既可以是抽象的，也可以提供getter和setter。介面中的屬性不能有後備欄位，因此介面中的getter或setter不能引用它們。

interface MyInterface {

    val prop: Int  //抽象的

    val propertyWithImplementation: String
        get() = "abc"

    fun bar()
    fun foo() {
        println("MyInterface.foo")
    }
}

class
 
 ChildOfInterface : MyInterface {
    override val prop: Int
        get() = 3 

    override fun bar() {
        foo()
    }

    override fun foo() {
        super.foo()
        println("ChildOfInterface.foo")
    }

}

也就是說介面的定義的屬性預設也是要覆寫的，如果不想子類覆寫，那麼需要提供get()設定值,並且只能使用get()來提供初始值。

解決覆寫衝突

當我們繼承了很多父類時，可能會出現繼承了同一個方法的多個實現。舉個例子：

interface A {
    fun foo() {
        println("A")
    }

    fun bar()

}

interface B {
    fun foo() {
        println("B")
    }

    fun bar() {
        println("bar")
    }

}

class C : A {
    override fun bar() {
        println("C.bar")
    }
}

class D : A, B {
    override fun foo() {

        super<A>.foo()
        super<B>.foo()
        println("D.foo")
    }

    override fun bar() {
        super<B>.bar()
    }
}

fun main(args: Array<String>) {
    var d = D()
    d.foo()
    d.bar()
}

這個在繼承中有講到，這兒就不贅述了。