În acest articol, veți afla despre interfețe și cum să le implementați în Kotlin cu ajutorul exemplelor.
Interfețele Kotlin sunt similare cu interfețele din Java 8. Ele pot conține definiții ale metodelor abstracte, precum și implementări ale metodelor non-abstracte. Cu toate acestea, ele nu pot conține nicio stare.
Adică, interfața poate avea proprietăți, dar trebuie să fie abstractă sau trebuie să ofere implementări pentru accesori.
Lectură recomandată: Clasa abstractă Kotlin
Clasele abstracte din Kotlin sunt similare cu interfața cu o diferență importantă. Nu este obligatoriu ca proprietățile unei clase abstracte să fie abstracte sau să ofere implementări pentru accesori.
Cum se definește o interfață?
Cuvântul cheie interfaceeste utilizat pentru a defini interfețele din Kotlin. De exemplu,
interface MyInterface (test var: String // abstract property fun foo () // abstract method fun hello () = "Hello there" // metodă cu implementare implicită)
Aici,
- se creează o interfață MyInterface.
- interfața are un test de proprietate abstractă și o metodă abstractă
foo(). - interfața are, de asemenea, o metodă non-abstractă
hello().
Cum se implementează interfața?
Iată cum o clasă sau un obiect poate implementa interfața:
interface MyInterface (test val: Int // abstract property fun foo (): String // abstract method (return String) fun hello () (// metodă cu implementare implicită // body (opțional))) clasă InterfaceImp: MyInterface (override test val: Int = 25 override fun foo () = "Lol" // alt cod)
Aici, o clasă InterfaceImp implementează interfața MyInterface.
Clasa suprascrie membrii abstracte (proprietatea și foo()metoda de testare ) ale interfeței.
Exemplu: Cum funcționează interfața?
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()) )
Când rulați programul, ieșirea va fi:
test = 25 Calling hello (): Bună ziua, amice! Apelarea și tipărirea foo (): Lol
După cum sa menționat mai sus, o interfață poate avea, de asemenea, o proprietate care oferă implementarea accesorului. De exemplu,
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) )
Când rulați programul, ieșirea va fi:
23
Aici, recuzita nu este abstractă. Cu toate acestea, este valabil în interiorul interfeței, deoarece oferă implementare pentru accesor.
Cu toate acestea, nu puteți face ceva de genul val prop: Int = 23în interiorul interfeței.
Implementarea a două sau mai multe interfețe într-o clasă
Kotlin nu permite moștenirea multiplă adevărată. Cu toate acestea, este posibil să implementați două sau mai multe interfețe într-o singură clasă. De exemplu,
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() )
Când rulați programul, ieșirea va fi:
Din interfața A Din interfața B
Rezolvarea conflictelor majore (interfață multiplă)
Să presupunem că două interfețe (A și B) au o metodă non-abstractă cu același nume (să spunem callMe()metodă). Ați implementat aceste două interfețe într-o clasă (să spunem C). Acum, dacă apelați callMe()metoda folosind obiectul clasei C, compilatorul va arunca o eroare. De exemplu,
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() )
Iată eroarea:
Eroare: (14, 1) Kotlin: Clasa „C” trebuie să suprascrie publicul deschis distractiv callMe (): Unitate definită în A deoarece moștenește mai multe metode de interfață ale acesteia
Pentru a rezolva această problemă, trebuie să furnizați propria implementare. Iată cum:
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() )
Acum, când rulați programul, ieșirea va fi:
Din interfața A Din interfața B
Aici, implementarea explicită a callMe()metodei este prevăzută în clasa C.
clasa C: A, B (override fun callMe () (super.callMe () super .callMe ()))
Declarația super.callMe()numește callMe()metoda clasei A. În mod similar, apelează metoda clasei .super.callMe()callMe()B
