Kotlin教學 » Kotlin介面

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 方法實現