Cum se realizează implementarea interfețelor în Kotlin?

Interfețele în Kotlin sunt implementate folosind cuvântul cheie implements (implicit în Kotlin, indicat simplu prin două puncte) sau by pentru delegare.

Principalele moduri de implementare:

1. Implementare directă: Obiectul sau clasa implementează toate membrii interfeței direct.

   interface MyInterface {
       fun doSomething()
       val myProperty: String
   }
   
   class MyClass : MyInterface {
       override fun doSomething() {
           println("Fac ceva în MyClass")
       }
   
       override val myProperty: String = "Salut"
   }
   

   Când se moștenește de la o clasă și se implementează interfețe simultan, clasa este indicată prima.

   open class BaseClass
   
   class AnotherClass : BaseClass(), MyInterface {
       override fun doSomething() {
           println("Fac ceva în AnotherClass")
       }
   
       override val myProperty: String = "Lume"
   }
   

2. Delegare de implementare: Implementarea interfeței este delegată unui alt obiect. Se folosește cuvântul cheie by. Acest lucru este util pentru compoziție și pentru evitarea problemelor cu moștenirea multiplă.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Acțiune realizată de DelegatedObject")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass delegă implementarea metodei performAction() obiectului di
   }
   

   În acest caz, ImplementingClass nu implementează performAction singură, în schimb, apelul performingClass.performAction() este redirecționat către di.performAction().

Atunci când implementează mai multe interfețe cu membri cu același nume, trebuie rezolvate conflictele, suprascriind explicit membrul și indicând de la ce interfață provine implementarea, folosind sintaxa <Interfață>.<membru>.

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() // Apelăm implementarea lui foo din InterfaceA
        super<InterfaceB>.foo() // Apelăm implementarea lui foo din InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Folosim implementarea lui bar din InterfaceB
    }
}