Kotlin Schnittstellen

Kotlin-Schnittstellen sind Java 8 ähnlich. Das Schlüsselwort interface wird verwendet, um Schnittstellen zu definieren, wodurch Methoden Standardimplementierungen haben können:

interface MyInterface { fun bar() //Nicht implementiert fun foo() { //Implementiert //Optionaler Methodenrumpf println("foo") } }

Schnittstellen implementieren

Eine Klasse oder ein Objekt kann eine oder mehrere Schnittstellen implementieren.

class Child : MyInterface { override fun bar() { //Methodenrumpf } }

Beispiel

interface MyInterface { fun bar() fun foo() { //Optionaler Methodenrumpf println("foo") } } class Child : MyInterface { override fun bar() { //Methodenrumpf println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); }

Das Ausgabeergebnis ist:

foo
bar

Eigenschaften in Schnittstellen

Eigenschaften in Schnittstellen können nur abstrakt sein; Initialisierungswerte sind nicht erlaubt. Schnittstellen speichern keine Eigenschaftswerte. Bei der Implementierung einer Schnittstelle müssen die Eigenschaften überschrieben werden:

interface MyInterface{ var name:String //name-Eigenschaft, abstrakt } class MyImpl:MyInterface{ override var name: String = "example" //Eigenschaft überschreiben }

Beispiel

interface MyInterface { var name:String //name-Eigenschaft, abstrakt fun bar() fun foo() { //Optionaler Methodenrumpf println("foo") } } class Child : MyInterface { override var name: String = "example" //Eigenschaft überschreiben override fun bar() { //Methodenrumpf println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); println(c.name) }

Das Ausgabeergebnis ist:

foo
bar
example

Funktionsüberschreibung

Bei der Implementierung mehrerer Schnittstellen können Sie auf das Problem stoßen, mehrere Implementierungen derselben Methode zu erben. Zum Beispiel:

Beispiel

interface A { fun foo() { print("A") } //Implementiert fun bar() //Nicht implementiert, kein Methodenkörper, abstrakt } interface B { fun foo() { print("B") } //Implementiert fun bar() { print("bar") } //Implementiert } class C : A { override fun bar() { print("bar") } //Überschreiben } class D : A, B { override fun foo() { super<A>.foo() super<B>.foo() } override fun bar() { super<B>.bar() } } fun main(args: Array<String>) { val d = D() d.foo(); d.bar(); }

Das Ausgabeergebnis ist:

ABbar

Im Beispiel definieren die Schnittstellen A und B beide die Methoden foo() und bar(). Beide implementieren foo(), und B implementiert bar(). Da C eine konkrete Klasse ist, die A implementiert, muss sie bar() überschreiben und diese abstrakte Methode implementieren.

Wenn wir jedoch D von A und B ableiten, müssen wir alle von mehreren Schnittstellen geerbten Methoden implementieren und angeben, wie D sie implementieren soll. Diese Regel gilt sowohl für Methoden, die eine einzelne Implementierung erben (bar()), als auch für Methoden, die mehrere Implementierungen erben (foo()).

Andere Erweiterungen