Wie werden Schnittstellen in Kotlin implementiert…

Interfaces in Kotlin werden mit dem Schlüsselwort implements (implizit in Kotlin, einfach durch Doppelpunkt angegeben) oder by für Delegierung implementiert.

Hauptimplementierungsarten:

Direkte Implementierung: Das Objekt oder die Klasse implementiert alle Mitglieder der Schnittstelle direkt.

interface MyInterface {
    fun doSomething()
    val myProperty: String
}

class MyClass : MyInterface {
    override fun doSomething() {
        println("Etwas tun in MyClass")
    }

    override val myProperty: String = "Hallo"
}

Bei gleichzeitiger Vererbung von einer Klasse und Implementierung von Schnittstellen wird die Klasse zuerst angegeben.

open class BaseClass

class AnotherClass : BaseClass(), MyInterface {
    override fun doSomething() {
        println("Etwas tun in AnotherClass")
    }

    override val myProperty: String = "Welt"
}

Delegierung der Implementierung: Die Implementierung der Schnittstelle wird an ein anderes Objekt delegiert. Es wird das Schlüsselwort by verwendet. Dies ist nützlich für Komposition und um Probleme mit Mehrfachvererbung zu vermeiden.

interface DelegatedInterface {
    fun performAction()
}

class DelegatedObject : DelegatedInterface {
    override fun performAction() {
        println("Aktion ausgeführt von DelegatedObject")
    }
}

class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
    // ImplementingClass delegiert die Ausführung von performAction() an das Objekt di
}

In diesem Fall implementiert ImplementingClass performAction nicht selbst, stattdessen wird der Aufruf performingClass.performAction() an di.performAction() weitergeleitet.

Bei der Implementierung mehrerer Schnittstellen mit gleichnamigen Mitgliedern müssen Konflikte aufgelöst werden, indem das Mitglied explizit überschrieben und angegeben wird, von welcher Schnittstelle die Implementierung stammt, unter Verwendung der Syntax <Schnittstelle>.<Mitglied>.

interface InterfaceA {
    fun foo() { println("InterfaceA") }
    fun bar()
}

interface InterfaceB {
    fun foo() { println("InterfaceB") }
    fun bar() { println("InterfaceB bar") }
}

class ResolvingConflict : InterfaceA, InterfaceB {
    override fun foo() {
        super<InterfaceA>.foo() // Ruft die Implementierung von foo aus InterfaceA auf
        super<InterfaceB>.foo() // Ruft die Implementierung von foo aus InterfaceB auf
    }

    override fun bar() {
        super<InterfaceB>.bar() // Verwendet die Implementierung von bar aus InterfaceB
    }
}

Wie werden Schnittstellen in Kotlin implementiert?