Kotlin
gränssnitt

Anmärkningar

Grundläggande gränssnitt

Ett Kotlin-gränssnitt innehåller deklarationer av abstrakta metoder och standardmetoderimplementering även om de inte kan lagra tillstånd.

interface MyInterface {
    fun bar()
}

Detta gränssnitt kan nu implementeras av en klass enligt följande:

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

Gränssnitt med standardimplementeringar

Ett gränssnitt i Kotlin kan ha standardimplementeringar för funktioner:

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

Klasser som implementerar sådana gränssnitt kan använda dessa funktioner utan att återimplementera

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

Egenskaper

Standardimplementeringar fungerar också för fastighetsmäklare och uppsättare:

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

Implementeringar av gränssnittstillbehör kan inte använda stödfält

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

Flera implementationer

När flera gränssnitt implementerar samma funktion, eller alla definierar en eller flera implementeringar, måste den härledda klassen manuellt lösa korrekt samtal

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

Egenskaper i gränssnitt

Du kan deklarera egenskaper i gränssnitt. Eftersom ett gränssnitt inte kan ha ett tillstånd kan du bara förklara en egenskap som abstrakt eller genom att tillhandahålla standardimplementering för accessorerna.

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

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

Konflikter vid implementering av flera gränssnitt med standardimplementeringar

När man implementerar mer än ett gränssnitt som har metoder med samma namn som innehåller standardimplementeringar är det tvetydigt för kompilatorn vilken implementering som ska användas. Vid en konflikt måste utvecklaren åsidosätta den motstridiga metoden och tillhandahålla en anpassad implementering. Det genomförandet kan välja att delegera till standardimplementeringarna eller inte.

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 nyckelord

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

Om metoden i gränssnittet har sin egen standardimplementering kan vi använda super-nyckelord för att komma åt det.

super.funcOne()