Kotlin
Schnittstellen

Bemerkungen

Grundlegende Schnittstelle

Eine Kotlin-Schnittstelle enthält Deklarationen abstrakter Methoden und Standardmethodenimplementierungen, obwohl sie keinen Status speichern können.

interface MyInterface {
    fun bar()
}

Diese Schnittstelle kann nun wie folgt von einer Klasse implementiert werden:

class Child : MyInterface {
   override fun bar() {
       print("bar() was called")
   }
}

Schnittstelle mit Standardimplementierungen

Eine Schnittstelle in Kotlin kann Standardimplementierungen für Funktionen haben:

interface MyInterface {
    fun withImplementation() {
      print("withImplementation() was called")
    }
}

Klassen, die solche Schnittstellen implementieren, können diese Funktionen ohne erneute Implementierung verwenden

class MyClass: MyInterface {
    // No need to reimplement here
}
val instance = MyClass()
instance.withImplementation()

Eigenschaften

Standardimplementierungen funktionieren auch für Property-Getter und -Setter:

interface MyInterface2 {
    val helloWorld
        get() = "Hello World!"
}

Implementierungen von Schnittstellen-Accessoren können keine Sicherungsfelder verwenden

interface MyInterface3 {
    // this property won't compile!
    var helloWorld: Int
        get() = field
        set(value) { field = value }
}

Mehrere Implementierungen

Wenn mehrere Schnittstellen dieselbe Funktion implementieren oder alle mit einer oder mehreren implementieren, muss die abgeleitete Klasse den richtigen Aufruf manuell auflösen

interface A {
    fun notImplemented()
    fun implementedOnlyInA() { print("only A") }
    fun implementedInBoth() { print("both, A") }
    fun implementedInOne() { print("implemented in A") }
}

interface B {
    fun implementedInBoth() { print("both, B") }
    fun implementedInOne() // only defined
}

class MyClass: A, B {
    override fun notImplemented() { print("Normal implementation") }

    // implementedOnlyInA() can by normally used in instances

    // class needs to define how to use interface functions
    override fun implementedInBoth() {
        super<B>.implementedInBoth()
        super<A>.implementedInBoth()
    }

    // even if there's only one implementation, there multiple definitions
    override fun implementedInOne() {
        super<A>.implementedInOne()
        print("implementedInOne class implementation")
    }
}

Eigenschaften in Schnittstellen

Sie können Eigenschaften in Schnittstellen deklarieren. Da eine Schnittstelle keinen Status haben kann, können Sie eine Eigenschaft nur als abstrakt deklarieren oder eine Standardimplementierung für die Zugriffsmethoden bereitstellen.

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

class Child : MyInterface {
    override val property: Int = 29
}

Konflikte bei der Implementierung mehrerer Schnittstellen mit Standardimplementierungen

Wenn Sie mehr als eine Schnittstelle mit gleichnamigen Methoden implementieren, die Standardimplementierungen enthalten, ist für den Compiler nicht eindeutig, welche Implementierung verwendet werden soll. Im Falle eines Konflikts muss der Entwickler die in Konflikt stehende Methode überschreiben und eine benutzerdefinierte Implementierung bereitstellen. Diese Implementierung kann sich dafür entscheiden, an die Standardimplementierungen zu delegieren oder nicht.

interface FirstTrait {
    fun foo() { print("first") }
    fun bar()
}

interface SecondTrait {
    fun foo() { print("second") }
    fun bar() { print("bar") }
}

class ClassWithConflict : FirstTrait, SecondTrait {
    override fun foo() {
        super<FirstTrait>.foo()  // delegate to the default implementation of FirstTrait
        super<SecondTrait>.foo() // delegate to the default implementation of SecondTrait
    }

    // function bar() only has a default implementation in one interface and therefore is ok.
}

Super Keyword

interface MyInterface {
    fun funcOne() {
        //optional body
        print("Function with default implementation")
    }
}

Wenn die Methode in der Schnittstelle über eine eigene Standardimplementierung verfügt, können Sie mit dem Schlüsselwort super auf sie zugreifen.

super.funcOne()