Kotlin
interfaces

Opmerkingen

Basisinterface

Een Kotlin-interface bevat verklaringen van abstracte methoden en standaardmethode-implementaties, hoewel deze de status niet kunnen opslaan.

interface MyInterface {
    fun bar()
}

Deze interface kan nu als volgt door een klasse worden geïmplementeerd:

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

Interface met standaardimplementaties

Een interface in Kotlin kan standaardimplementaties hebben voor functies:

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

Klassen die dergelijke interfaces implementeren, kunnen die functies gebruiken zonder opnieuw te implementeren

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

Eigendommen

Standaardimplementaties werken ook voor onroerend goed getters en setters:

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

Implementaties van interface-accessors kunnen geen back-upvelden gebruiken

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

Meerdere implementaties

Wanneer meerdere interfaces dezelfde functie implementeren, of allemaal definiëren met een of meer implementaties, moet de afgeleide klasse de juiste oproep handmatig oplossen

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")
    }
}

Eigenschappen in interfaces

U kunt eigenschappen in interfaces declareren. Aangezien een interface geen status kan hebben, kunt u een eigenschap alleen als abstract verklaren of door de standaardimplementatie voor de accessors te bieden.

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

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

Conflicten bij het implementeren van meerdere interfaces met standaardimplementaties

Bij het implementeren van meer dan één interface met methoden met dezelfde naam die standaardimplementaties bevatten, is het voor de compiler onduidelijk welke implementatie moet worden gebruikt. In het geval van een conflict moet de ontwikkelaar de conflicterende methode overschrijven en een aangepaste implementatie bieden. Die implementatie kan ervoor kiezen om te delegeren naar de standaardimplementaties of niet.

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 trefwoord

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

Als de methode in de interface zijn eigen standaardimplementatie heeft, kunnen we superzoekwoord gebruiken om er toegang toe te krijgen.

super.funcOne()