¿Cómo se implementan las interfaces en Kotlin?

Las interfaces en Kotlin se implementan usando la palabra clave implements (implícito en Kotlin, simplemente se indica con dos puntos) o by para delegar.

Formas principales de implementación:

1. Implementación directa: El objeto o clase implementa todos los miembros de la interfaz directamente.

   interface MyInterface {
       fun doSomething()
       val myProperty: String
   }
   
   class MyClass : MyInterface {
       override fun doSomething() {
           println("Haciendo algo en MyClass")
       }
   
       override val myProperty: String = "Hola"
   }
   

   Cuando se hereda de una clase y se implementan interfaces simultáneamente, la clase se indica primero.

   open class BaseClass
   
   class AnotherClass : BaseClass(), MyInterface {
       override fun doSomething() {
           println("Haciendo algo en AnotherClass")
       }
   
       override val myProperty: String = "Mundo"
   }
   

2. Delegación de implementación: La implementación de la interfaz se delega a otro objeto. Se usa la palabra clave by. Esto es útil para composición y para evitar problemas con la herencia múltiple de implementación.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Acción realizada por DelegatedObject")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass delega la implementación del método performAction() al objeto di
   }
   

   En este caso, ImplementingClass no implementa performAction por sí misma, en su lugar, la llamada a performingClass.performAction() se redirige a di.performAction().

Al implementar varias interfaces con miembros con el mismo nombre, es necesario resolver conflictos, sobrescribiendo explícitamente el miembro y especificando de qué interfaz se toma la implementación, usando la sintaxis <Interfaz>.<miembro>.

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() // Llamada a la implementación de foo de InterfaceA
        super<InterfaceB>.foo() // Llamada a la implementación de foo de InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Usando la implementación de bar de InterfaceB
    }
}