Kotlin接口

接口是類的藍圖(基礎框架)。Kotlin接口類似於Java 8中的接口，它包含抽象方法聲明以及方法的實現。

定義接口

接口是使用interface關鍵字來定義的。 例如：

interface MyInterface {
    val id: Int // abstract property  
    fun absMethod()// abstract method  
    fun doSomthing() {
        // optional body  
    }
}

默認情況下，僅在沒有方法體(方法只聲明未實現)的情況下聲明的方法是抽象的。

爲什麼要使用Kotlin接口？

以下是使用接口的理由：

• 使用接口支持多重繼承功能。
• 它可以用來實現鬆耦合。
• 它用於實現抽象。

一個類只能擴展一個超類但可以實現多個接口。 父類或接口實現的擴展是在子類中使用(:)運算符完成的。

實現接口

在這個例子中，在InterfaceImp類中實現了MyInterface接口。 InterfaceImp類提供了在MyInterface接口中聲明的屬性id和抽象方法absMethod()的實現。

interface MyInterface  {
    var id: Int            // abstract property
    fun absMethod():String    // abstract method
    fun doSomthing() {
        println("MyInterface做了一些工作")
    }
}
class InterfaceImp : MyInterface {
    override var id: Int = 10010
    override fun absMethod(): String{
        return "實現抽象方法.."
    }
}
fun main(args: Array<String>) {
    val obj = InterfaceImp()
    println("調用覆蓋id值，當前 ID = ${obj.id}")
    obj.doSomthing()
    println(obj.absMethod())
}

執行上面示例代碼，得到以下結果 -

調用覆蓋id值，當前 ID = 10010
MyInterface做了一些工作
實現抽象方法..

實現多個接口

可以在同一個類中實現不同接口的多個抽象方法。 所有抽象方法都必須在子類中實現。 可以從派生類調用其他非抽象的接口方法。

例如，分別使用抽象方法doSomthing()和absMethod()創建兩個接口MyInterface1和MyInterface2，然後在派生類MyClass中覆蓋這些抽象方法。

interface MyInterface1 {
    fun doSomthing()
}
interface MyInterface2 {
    fun absMethod()
}
class MyClass : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        println("overriding doSomthing() of MyInterface1")
    }

    override fun absMethod() {
        println("overriding absMethod() of MyInterface2")
    }
}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
    myClass.absMethod()
}

執行上面示例代碼，得到以下結果 -

overriding doSomthing() of MyInterface1
overriding absMethod() of MyInterface2

解決具有相同方法的不同接口覆蓋衝突

讓我們先來看看一個示例，接口MyInterface1和接口MyInterface2都包含相同的非抽象方法。 MyClass類提供了這些接口的實現。 使用MyClass對象調用接口方法時會產生錯誤。

interface MyInterface1 {
    fun doSomthing(){
        println("overriding doSomthing() of MyInterface1")
    }
}
interface MyInterface2 {
    fun doSomthing(){
        println("overriding doSomthing() of MyInterface2")
    }
}
class MyClass : MyInterface1, MyInterface2 {

}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
}

執行上面示例代碼，得到以下結果 -

Error:(11, 1) Kotlin: Class 'MyClass' must override public open fun doSomthing(): Unit defined in MyInterface1 because it inherits multiple interface methods of it

要解決上述問題，需要指定調用的特定接口方法。看下面的例子。

在下面的示例中，兩個接口MyInterface1和MyInterface2分別包含兩個抽象方法adsMethod()和absMethod(name：String)以及非抽象方法doSomthing()。 MyClass類實現接口和覆蓋抽象方法absMethod()和absMethod(name：String)。 要覆蓋非抽象方法doSomthing()，需要使用super關鍵字指定接口名稱爲super <interface_name> .methodName()。

示例1

interface MyInterface1 {
    fun doSomthing() {
        println("MyInterface 1 做了一些工作")
    }
    fun absMethod()
}
interface MyInterface2 {
    fun doSomthing(){
        println("MyInterface 2 做了一些工作")
    }
    fun absMethod(name: String)
}
class MyClass : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        super<MyInterface2>.doSomthing()
    }

    override fun absMethod() {
        println("實現了 MyInterface1 的 absMethod() 方法")
    }
    override fun absMethod(n: String) {
        println("實現了 MyInterface1 的 absMethod(name) 方法，名稱是：$n")
    }
}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
    myClass.absMethod()
    myClass.absMethod("Maxsu")
}

執行上面示例代碼，得到以下結果 -

MyInterface 2 做了一些工作
實現了 MyInterface1 的 absMethod() 方法
實現了 MyInterface1 的 absMethod(name) 方法，名稱是：Maxsu

示例2

interface MyInterface1 {
    fun doSomthing() {
        println("MyInterface1 doSomthing方法執行")
    }
    fun absMethod()
}

interface MyInterface2 {
    fun doSomthing() {
        println("MyInterface2 doSomthing方法執行")
    }
    fun absMethod() {
        println("MyInterface2 absMethod方法執行")
    }

}

class C : MyInterface1 {
    override fun absMethod() {
        println("MyInterface1 absMethod 方法實現")
    }
}

class D : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        super<MyInterface1>.doSomthing()
        super<MyInterface2>.doSomthing()
    }

    override fun absMethod() {
        super<MyInterface2>.absMethod()
    }
}

fun main(args: Array<String>) {
    val d = D()
    val c = C()
    d.doSomthing()
    d.absMethod()
    c.doSomthing()
    c.absMethod()
}

執行上面示例代碼，得到以下結果 -

MyInterface1 doSomthing方法執行
MyInterface2 doSomthing方法執行
MyInterface2 absMethod方法執行
MyInterface1 doSomthing方法執行
MyInterface1 absMethod 方法實現