Hogyan valósul meg az interfészek megvalósítása Kotlinben?

A Kotlinben az interfészeket a implements kulcsszóval (amely implicit módon Kotlinben, egyszerűen kettő ponttal van jelölve) vagy by-val történő delegálással valósítják meg.

A megvalósítás fő módszerei:

1. Közvetlen megvalósítás: A tárgy vagy osztály közvetlenül valósítja meg az összes interfész tagját.

   interface MyInterface {
       fun doSomething()
       val myProperty: String
   }
   
   class MyClass : MyInterface {
       override fun doSomething() {
           println("Valami csinálása a MyClass-ben")
       }
   
       override val myProperty: String = "Helló"
   }
   

   Amikor egy osztály öröklődik egy osztályból és egyszerre valósít meg interfészeket, az osztályt elsőként kell megadni.

   open class BaseClass
   
   class AnotherClass : BaseClass(), MyInterface {
       override fun doSomething() {
           println("Valami csinálása az AnotherClass-ben")
       }
   
       override val myProperty: String = "Világ"
   }
   

2. Implementáció delegálása: Az interfész megvalósítása egy másik objektumnak van delegálva. A by kulcsszót használjuk. Ez hasznos kompozícióhoz és a több öröklés problémáinak elkerüléséhez.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Akció végrehajtva a DelegatedObject által")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass delegálja a performAction() metódus megvalósítását a di objektumnak
   }
   

   Ebben az esetben, az ImplementingClass nem valósítja meg saját maga a performAction-t, hanem a performingClass.performAction() hívás átirányításra kerül a di.performAction()-ra.

Több interfész megvalósításakor, amelyek ugyanazokat a tagokat tartalmazzák, konfliktusokat kell megoldani, kifejezetten felülírva a tagot, és megadva, melyik interfészből származik a megvalósítás, a <Interfész>.<tag> szintaxist használva.

interface InterfaceA {
    fun foo() { println("InterfaceA") }
    fun bar()
}

interface InterfaceB {
    fun foo() { println("InterfaceB") }
    fun bar() { println("InterfaceB bar") }
}

class ResolvingConflict : InterfaceA, InterfaceB {
    override fun foo() {
        super<InterfaceA>.foo() // Az InterfaceA-ból származó foo meghívása
        super<InterfaceB>.foo() // Az InterfaceB-ből származó foo meghívása
    }

    override fun bar() {
        super<InterfaceB>.bar() // Az InterfaceB-ből származó bar használata
    }
}