¿Qué es la delegación en Kotlin?

La delegación en Kotlin es un patrón de diseño en el que un objeto (delegado) asume la responsabilidad de realizar una tarea en nombre de otro objeto. Kotlin soporta la delegación nativamente a nivel de sintaxis.

Existen dos tipos principales de delegación en Kotlin:

1. Delegación de clase (Class Delegation): Permite que una clase A implemente una interfaz, delegando todas las llamadas a los métodos de esa interfaz a otro objeto B.

   interface Base {
       fun printMessage()
   }
   
   class BaseImpl(val x: Int) : Base {
       override fun printMessage() {
           // Implementación del método de la interfaz
           println(x)
       }
   }
   
   class Derived(b: Base) : Base by b // Delegación a la clase BaseImpl
   

   En el ejemplo, Derived delega la implementación de Base al objeto b.

2. Delegación de propiedades (Delegated Properties): Permite delegar la lógica de obtención y establecimiento del valor de una propiedad a otro objeto. Kotlin proporciona varios delegados estándar:

   • lazy() para inicialización diferida.

     val lazyValue: String by lazy {
         // Se ejecuta solo en la primera referencia a lazyValue
         println("¡se calcula!")
         "Hola"
     }
     

   • Delegates.observable() para notificar a los oyentes sobre cambios.

     import kotlin.properties.Delegates
     
     var name: String by Delegates.observable("valor inicial") {
         prop, old, new ->
         println("$old -> $new")
     }
     

   • Delegates.vetoable() para interceptar cambios antes de aplicarlos.

     import kotlin.properties.Delegates
     
     var max: Int by Delegates.vetoable(0) {
         prop, old, new -> new > old
     }
     

   • Delegados para enlazar con propiedades de mapas (map).

     class User(val map: Map<String, Any?>) {
         val name: String by map
         val age: Int by map
     }
     

     Uso: User(mapOf("name" to "John Doe", "age" to 25))

Ventajas del uso de delegación en Kotlin:

• Reducción de código repetitivo: Redirige automáticamente llamadas a métodos o lógica de propiedades.
• Reutilización de código: Posibilidad de usar delegados existentes o crear los propios.
• Separación de responsabilidades: Claramente divide la lógica de la propiedad o interfaz.
• Flexibilidad: Permite cambiar el comportamiento de la delegación sin modificar la clase.