Ebben a cikkben megismerheti az interfészeket és annak megvalósítását Kotlinban példák segítségével.
A Kotlin interfészek hasonlóak a Java 8 felületéhez. Tartalmazhatnak absztrakt módszerek definícióit, valamint nem absztrakt módszerek megvalósításait. Nem tartalmazhatnak azonban állapotot.
Jelentése: az interfésznek lehet tulajdonsága, de absztraktnak kell lennie, vagy hozzáférési megvalósításokat kell biztosítania.
Ajánlott irodalom: Kotlin Abstract Class
Az absztrakt osztályok Kotlinban hasonlóak az interfészhez, egy fontos különbséggel. Nem kötelező, hogy az absztrakt osztály tulajdonságai elvontak legyenek, vagy hozzáférési megvalósításokat biztosítsanak.
Hogyan definiálható egy interfész?
A Kulcsszó interfaceaz interfészek meghatározására szolgál Kotlinban. Például,
felület MyInterface (var teszt: String // absztrakt tulajdonság fun foo () // abstract method fun hello () = "Hello there" // módszer alapértelmezett megvalósítással)
Itt,
- létrejön egy MyInterface felület.
- a felületen van egy elvont tulajdonság teszt és egy elvont módszer
foo(). - a felületnek van egy nem elvont módszere is
hello().
Hogyan kell megvalósítani az interfészt?
Így képes egy osztály vagy objektum megvalósítani az interfészt:
interfész MyInterface (val teszt: Int // absztrakt tulajdonság fun foo (): String // absztrakt metódus (String-t ad vissza) fun hello () (// metódus alapértelmezett megvalósítással // body (opcionális))) osztály InterfaceImp: MyInterface (felülbírálás val teszt: Int = 25 felülírja a szórakoztató foo-t () = "Lol" // egyéb kód)
Itt egy osztályú InterfaceImp hajtja végre a MyInterface felületet.
Az osztály felülírja foo()az interfész elvont tagjait (teszt tulajdonság és módszer).
Példa: Hogyan működik az interfész?
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()) )
A program futtatásakor a kimenet a következő lesz:
teszt = 25 Helló (): Helló, haver! Hívás és nyomtatás foo (): Lol
Mint fent említettük, egy interfésznek lehet olyan tulajdonsága is, amely hozzáférés-megvalósítást biztosít. Például,
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) )
A program futtatásakor a kimenet a következő lesz:
23
Itt a prop nem elvont. Ez azonban érvényes az interfészen belül, mert megvalósítást biztosít az accessor számára.
Az val prop: Int = 23interfészen belül azonban nem tehet ilyet .
Két vagy több interfész megvalósítása egy osztályban
Kotlin nem engedélyezi az igazi többszörös öröklést. Lehetséges azonban két vagy több interfész megvalósítása egyetlen osztályban. Például,
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() )
A program futtatásakor a kimenet a következő lesz:
A felületről A B felületről
Felülbíráló konfliktusok megoldása (több interfész)
Tegyük fel, hogy két interfész (A és B) rendelkezik egy nem absztrakt módszerrel, azonos névvel (mondjuk callMe()módszerrel). Ezt a két interfészt implementálta egy osztályban (mondjuk C). Most, ha a callMe()metódust a C osztály objektumával hívja meg , a fordító hibát dob. Például,
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() )
Itt van a hiba:
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.
