Kotlin-grensesnitt (med eksempler)

I denne artikkelen vil du lære om grensesnitt og hvordan du implementerer det i Kotlin ved hjelp av eksempler.

Kotlin-grensesnitt ligner grensesnitt i Java 8. De kan inneholde definisjoner av abstrakte metoder samt implementeringer av ikke-abstrakte metoder. Imidlertid kan de ikke inneholde noen tilstand.

Betydning, grensesnitt kan ha eiendom, men det må være abstrakt eller må gi tilgangsimplementeringer.

Anbefalt lesing: Kotlin Abstract Class

Abstrakte klasser i Kotlin ligner på grensesnittet med en viktig forskjell. Det er ikke obligatorisk at egenskapene til en abstrakt klasse er abstrakte eller gir implementeringer av accessor.

Hvordan definere et grensesnitt?

Nøkkelord interfacebrukes til å definere grensesnitt i Kotlin. For eksempel,

 grensesnitt MyInterface (var test: String // abstrakt eiendom moro foo () // abstrakt metode moro hei () = "Hei der" // metode med standard implementering)

Her,

  • et grensesnitt MyInterface opprettes.
  • grensesnittet har en abstrakt egenskapstest og en abstrakt metode foo().
  • grensesnittet har også en ikke-abstrakt metode hello().

Hvordan implementere grensesnitt?

Slik kan en klasse eller et objekt implementere grensesnittet:

 grensesnitt MyInterface (val test: Int // abstrakt eiendom moro foo (): String // abstrakt metode (returnerer String) moro hei () (// metode med standard implementering // body (valgfritt))) klasse InterfaceImp: MyInterface (overstyring val test: Int = 25 override fun foo () = "Lol" // annen kode)

Her implementerer en klasse InterfaceImp MyInterface-grensesnittet.

Klassen overstyrer abstrakte medlemmer (testegenskap og foo()metode) av grensesnittet.

Eksempel: Hvordan fungerer grensesnittet?

 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()) )

Når du kjører programmet, vil utdataene være:

test = 25 Ringer hei (): Hei, venn! Ringe og trykke foo (): Lol

Som nevnt ovenfor kan et grensesnitt også ha en egenskap som gir implementering av tilgang. For eksempel,

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

Når du kjører programmet, vil utdataene være:

 23

Her er ikke rekvisitt abstrakt. Det er imidlertid gyldig i grensesnittet fordi det gir implementering for accessor.

Du kan imidlertid ikke gjøre noe som val prop: Int = 23inne i grensesnittet.

Implementering av to eller flere grensesnitt i en klasse

Kotlin tillater ikke ekte multipel arv. Det er imidlertid mulig å implementere to eller flere grensesnitt i en enkelt klasse. For eksempel,

 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() )

Når du kjører programmet, vil utdataene være:

 Fra grensesnitt A Fra grensesnitt B

Løse overordnede konflikter (flere grensesnitt)

Anta at to grensesnitt (A og B) har en ikke-abstrakt metode med samme navn (la oss si callMe()metoden). Du implementerte disse to grensesnittene i en klasse (la oss si C). Nå, hvis du kaller callMe()metoden ved hjelp av objektet i klasse C, vil kompilatoren kaste feil. For eksempel,

 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() )

Her er feilen:

 Error:(14, 1) Kotlin: Class 'C' must override public open fun callMe(): Unit defined in A because it inherits multiple interface methods of it

To solve this issue, you need to provide your own implementation. Here's how:

 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() )

Now when you run the program, the output will be:

 From interface A From interface B

Here, explicit implementation of callMe() method is provided in class C.

 class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) )

The statement super.callMe() calls the callMe() method of class A. Similarly, super.callMe() calls the callMe() method of class B.

Interessante artikler...