Hoe wordt de implementatie van interfaces gedaan in…

Interfaces in Kotlin worden geïmplementeerd met behulp van het sleutelwoord implements (impliciet in Kotlin, gewoon aangegeven met een dubbele punt) of by voor delegatie.

Belangrijkste implementatiemethoden:

Directe implementatie: Het object of de klasse implementeert alle leden van de interface direct.

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

class MyClass : MyInterface {
    override fun doSomething() {
        println("Iets doen in MyClass")
    }

    override val myProperty: String = "Hallo"
}

Bij het erven van een klasse en het gelijktijdig implementeren van interfaces, wordt de klasse eerst aangegeven.

open class BaseClass

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

    override val myProperty: String = "Wereld"
}

Delegatie van implementatie: De implementatie van de interface wordt gedelegeerd aan een ander object. by wordt gebruikt. Dit is handig voor compositie en om problemen met meervoudige overerving te voorkomen.

interface DelegatedInterface {
    fun performAction()
}

class DelegatedObject : DelegatedInterface {
    override fun performAction() {
        println("Actie uitgevoerd door DelegatedObject")
    }
}

class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
    // ImplementingClass delegeert de implementatie van performAction() aan het object di
}

In dit geval, ImplementingClass implementeert performAction niet zelf, in plaats daarvan wordt de aanroep performingClass.performAction() doorgestuurd naar di.performAction().

Bij het implementeren van meerdere interfaces met leden met dezelfde naam, moeten conflicten worden opgelost door het lid expliciet te overschrijven en aan te geven van welke interface de implementatie afkomstig is, met behulp van de syntaxis <Interface>.<lid>.

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() // Roept de implementatie van foo uit InterfaceA aan
        super<InterfaceB>.foo() // Roept de implementatie van foo uit InterfaceB aan
    }

    override fun bar() {
        super<InterfaceB>.bar() // Gebruikt de implementatie van bar uit InterfaceB
    }
}

Hoe wordt de implementatie van interfaces gedaan in Kotlin?