In questo articolo imparerai le interfacce e come implementarle in Kotlin con l'aiuto di esempi.
Le interfacce di Kotlin sono simili alle interfacce in Java 8. Possono contenere definizioni di metodi astratti così come implementazioni di metodi non astratti. Tuttavia, non possono contenere alcuno stato.
Significato, l'interfaccia può avere proprietà ma deve essere astratta o deve fornire implementazioni accessorie.
Letture consigliate: Kotlin Abstract Class
Le classi astratte in Kotlin sono simili all'interfaccia con una differenza importante. Non è obbligatorio che le proprietà di una classe astratta siano astratte o forniscano implementazioni di funzioni di accesso.
Come definire un'interfaccia?
La parola chiave interfaceviene utilizzata per definire le interfacce in Kotlin. Per esempio,
interface MyInterface (var test: String // abstract property fun foo () // abstract method fun hello () = "Hello there" // metodo con implementazione predefinita)
Qui,
- viene creata un'interfaccia MyInterface.
- l'interfaccia ha un test di proprietà astratto e un metodo astratto
foo(). - l'interfaccia ha anche un metodo non astratto
hello().
Come implementare l'interfaccia?
Ecco come una classe o un oggetto può implementare l'interfaccia:
interface MyInterface (val test: Int // proprietà astratta fun foo (): String // metodo astratto (restituisce String) fun hello () (// metodo con implementazione predefinita // body (opzionale))) class InterfaceImp: MyInterface (override val test: Int = 25 sovrascrive fun foo () = "Lol" // altro codice)
Qui, una classe InterfaceImp implementa l'interfaccia MyInterface.
La classe sovrascrive i membri astratti (proprietà e foo()metodo di test ) dell'interfaccia.
Esempio: come funziona l'interfaccia?
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()) )
Quando esegui il programma, l'output sarà:
test = 25 Calling hello (): Hello there, amico! Chiamare e stampare foo (): Lol
Come accennato in precedenza, un'interfaccia può anche avere una proprietà che fornisce l'implementazione della funzione di accesso. Per esempio,
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) )
Quando esegui il programma, l'output sarà:
23
Qui, il puntello non è astratto. Tuttavia, è valido all'interno dell'interfaccia perché fornisce l'implementazione per la funzione di accesso.
Tuttavia, non puoi fare qualcosa di simile val prop: Int = 23all'interno dell'interfaccia.
Implementazione di due o più interfacce in una classe
Kotlin non consente la vera ereditarietà multipla. Tuttavia, è possibile implementare due o più interfacce in una singola classe. Per esempio,
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() )
Quando esegui il programma, l'output sarà:
Dall'interfaccia A Dall'interfaccia B
Risoluzione dei conflitti di override (interfacce multiple)
Supponiamo che due interfacce (A e B) abbiano un metodo non astratto con lo stesso nome (diciamo callMe()metodo). Hai implementato queste due interfacce in una classe (diciamo C). Ora, se chiami il callMe()metodo usando l'oggetto della classe C, il compilatore genererà un errore. Per esempio,
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() )
Ecco l'errore:
Errore: (14, 1) Kotlin: la classe 'C' deve sovrascrivere il divertimento aperto pubblico callMe (): unità definita in A perché ne eredita più metodi di interfaccia
Per risolvere questo problema, è necessario fornire la propria implementazione. Ecco come:
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() )
Ora quando esegui il programma, l'output sarà:
Dall'interfaccia A Dall'interfaccia B
Qui, l'implementazione esplicita del callMe()metodo è fornita nella classe C.
classe C: A, B (sovrascrivi fun callMe () (super.callMe () super .callMe ()))
L'istruzione super.callMe()chiama il callMe()metodo della classe A. Allo stesso modo, chiama il metodo della classe .super.callMe()callMe()B
