Kotlin Interface (Interface)

在本文中，您将借助示例学习有关接口以及如何在Kotlin中实现接口的知识。

Kotlin接口类似于Java 8中的接口。它们可以包含抽象方法的定义以及非抽象方法的实现。但是，它们不能包含任何状态。

也就是说，接口可能有属性，但它必须是抽象的或者必须提供访问器实现。

推荐阅读： Kotlin 抽象类

Kotlin中的抽象类与接口相似，但有一个重要区别。抽象类的属性不是必须抽象的或提供访问器实现的。

如何定义接口？

关键字interface用于在Kotlin中定义接口。例如，

interface MyInterface {
　　　　var test: String　　　//抽象属性
　　　　fun foo()　　　　　　　　　　//抽象方法
　　　　fun hello() = "Hello there"　//具有默认实现的方法
}

这里，

• 创建接口 MyInterface。
  

• 该接口有一个抽象属性 test 和一个抽象方法 foo()。
  

• 该接口还具有非抽象方法 hello()。

如何实现接口？

这是类或对象如何实现接口的方法：

interface MyInterface {
　　　　val test: Int　　　//抽象属性
　　　　fun foo() : String　　　//抽象方法（返回字符串）
　　　　fun hello() {　　　//具有默认实现的方法
　　　　　　　　//　body （可选）
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "Lol"
　　　　//其他代码
}

在这里，InterfaceImp 类实现了 MyInterface 接口。

该类重写接口的抽象成员（test属性 和 foo()方法）。

示例：接口如何工作？

interface MyInterface {
　　　　val test: Int
　　　　fun foo() : String
　　　　fun hello() {
　　　　　　　　println("你好，伙计!")
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "Lol"
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println("test = ${obj.test}")
　　　　print("Aufruf von hello(): ")
　　　　obj.hello()
　　　　print("Aufruf und Ausgabe von foo(): ")
　　　　println(obj.foo())
}

Wenn das Programm ausgeführt wird, ist die Ausgabe:

test =　25
Aufruf von hello(): 你好，伙计!
Aufruf und Ausgabe von foo(): Lol

Wie bereits erwähnt, können Schnittstellen auch Eigenschaften mit zugriffsnehmerbereiten Implementierungen haben. Zum Beispiel

interface MyInterface {
　　　　//Eigenschaften mit Implementierung
　　　　val prop: Int
　　　　　　　　get() =　23
}
class InterfaceImp: MyInterface {
　　　　//Klassenkörper
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println(obj.prop)
}

Wenn das Programm ausgeführt wird, ist die Ausgabe:

23

Hier ist prop nicht abstrakt, aber es ist im Interface gültig, weil es die Implementierung des Zugriffsnehmers bereitstellt.

Sie können jedoch nicht ähnliche Operationen in einer Schnittstelle ausführen wie val prop: Int = 23 Operationen.

Implementierung mehrerer Interfaces in einer Klasse

Kotlin ermöglicht keine wahre Mehrvererbung. Es ist jedoch möglich, zwei oder mehrere Interfaces in einer Klasse zu implementieren. Zum Beispiel

interface A {
　　　　fun callMe() {
　　　　　　　　println("von Interface A")
　　　　}
}
interface B {
　　　　fun callMeToo() {
　　　　　　　　println("von Interface B")
　　　　}
}
//Implementierung der beiden Interfaces A und B
class Child: A, B
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
　　　　obj.callMeToo()
}

Wenn das Programm ausgeführt wird, ist die Ausgabe:

von Interface A
von Interface B

Lösung von Überschreibungskonflikten (mehrere Interfaces)

Angenommen, zwei Interfaces (A und B) haben nicht-abstracte Methoden mit demselben Namen (angenommen callMe() Methode). Sie implementieren diese beiden Interfaces in einer Klasse (angenommen C). Wenn Sie nun ein Objekt der Klasse C aufrufen und die Methode callMe() aufrufen, wirft der Compiler einen Fehler. Zum Beispiel

interface A {
　　　　fun callMe() {
　　　　　　　　println("Interface A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("Interface B")
　　　　}
}
class Child: A, B　
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
}

Dies ist der ausgelöste Fehler:

Fehler:(14,　1): Kotlin: Die Klasse 'C' muss die öffentliche offene Funktion callMe(): Unit überschreiben, die in A definiert ist, da sie mehrere Interface-Methoden desselben inhert,

Um dieses Problem zu lösen, müssen Sie Ihre eigene Implementierung bereitstellen. Hier ist, wie man das macht:

interface A {
　　　　fun callMe() {
　　　　　　　　println("Interface A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("Interface B")
　　　　}
}
class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}
fun main(args: Array<String>) {
　　　　val　obj　=　C()
　　　　obj.callMe()
}

Jetzt wird, wenn Sie das Programm ausführen, die Ausgabe sein:

Interface　　A
Interface　　B

Hier wird in der Klasse C eine explizite Implementierung der Methode callMe() bereitgestellt.

class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}

Der Ausdruck super<A>.callMe() ruft die Methode callMe() der Klasse A auf. Ähnlich ruft super<B>.callMe() die Methode callMe() der Klasse B auf.