In dit artikel leer je met behulp van voorbeelden over interfaces en hoe je deze in Kotlin kunt implementeren.
Kotlin-interfaces zijn vergelijkbaar met interfaces in Java 8. Ze kunnen zowel definities van abstracte methoden als implementaties van niet-abstracte methoden bevatten. Ze kunnen echter geen enkele staat bevatten.
Dit betekent dat de interface een eigenschap kan hebben, maar deze moet abstract zijn of moet accessor-implementaties bieden.
Aanbevolen literatuur: Kotlin Abstract Class
Abstracte klassen in Kotlin zijn vergelijkbaar met interface met een belangrijk verschil. Het is niet verplicht dat eigenschappen van een abstracte klasse abstract zijn of accessorimplementaties bieden.
Hoe definieer je een interface?
Sleutelwoord interfacewordt gebruikt om interfaces in Kotlin te definiëren. Bijvoorbeeld,
interface MyInterface (var test: String // abstracte eigenschap fun foo () // abstracte methode fun hello () = "Hallo daar" // methode met standaardimplementatie)
Hier,
- er wordt een interface MyInterface gemaakt.
- de interface heeft een abstracte eigenschapstest en een abstracte methode
foo(). - de interface heeft ook een niet-abstracte methode
hello().
Hoe interface te implementeren?
Hier is hoe een klasse of object de interface kan implementeren:
interface MyInterface (val test: Int // abstracte eigenschap fun foo (): String // abstracte methode (retourneert String) fun hello () (// methode met standaardimplementatie // body (optioneel))) class InterfaceImp: MyInterface (overschrijven val test: Int = 25 override fun foo () = "Lol" // andere code)
Hier implementeert een klasse InterfaceImp de MyInterface-interface.
De klasse overschrijft abstracte leden (testeigenschap en foo()methode) van de interface.
Voorbeeld: hoe interface werkt?
interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )
Wanneer u het programma uitvoert, is de uitvoer:
test = 25 Hallo (): Hallo daar, maat! Bellen en afdrukken foo (): Lol
Zoals hierboven vermeld, kan een interface ook een eigenschap hebben die accessorimplementatie biedt. Bijvoorbeeld,
interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )
Wanneer u het programma uitvoert, is de uitvoer:
23
Hier is prop niet abstract. Het is echter geldig in de interface omdat het implementatie voor accessor biedt.
U kunt echter niet zoiets als val prop: Int = 23in de interface doen.
Implementatie van twee of meer interfaces in een klas
Kotlin staat geen echte meervoudige overerving toe. Het is echter mogelijk om twee of meer interfaces in één klasse te implementeren. Bijvoorbeeld,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )
Wanneer u het programma uitvoert, is de uitvoer:
Vanaf interface A Vanaf interface B
Overheersende conflicten oplossen (meervoudige interface)
Stel dat twee interfaces (A en B) een niet-abstracte methode hebben met dezelfde naam (laten we zeggen callMe()methode). Je hebt deze twee interfaces geïmplementeerd in een klasse (laten we zeggen C). Als je de callMe()methode nu aanroept met het object van klasse C, zal de compiler een fout genereren. Bijvoorbeeld,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )
Hier is de fout:
Fout: (14, 1) Kotlin: Klasse 'C' moet public open fun callMe (): eenheid gedefinieerd in A overschrijven omdat het meerdere interfacemethoden ervan erft
Om dit probleem op te lossen, moet u voor uw eigen implementatie zorgen. Hier is hoe:
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )
Wanneer u het programma nu uitvoert, is de uitvoer:
Vanaf interface A Vanaf interface B
Hier wordt expliciete implementatie van de callMe()methode gegeven in klasse C.
klasse C: A, B (override fun callMe () (super.callMe () super .callMe ()))
De instructie super.callMe()roept de callMe()methode van klasse A aan. Evenzo roept de methode van klasse op .super.callMe()callMe()B
