O que é delegação em Kotlin?

A delegação em Kotlin é um padrão de design onde um objeto (delegado) assume a responsabilidade de executar uma tarefa em nome de outro objeto. Kotlin suporta delegação nativamente ao nível da sintaxe.

Existem dois principais tipos de delegação em Kotlin:

1. Delegação de classe (Class Delegation): Permite que uma classe A implemente uma interface, delegando todas as chamadas de métodos dessa interface a outro objeto B.

   interface Base {
       fun printMessage()
   }
   
   class BaseImpl(val x: Int) : Base {
       override fun printMessage() {
           // Implementação do método da interface
           println(x)
       }
   }
   
   class Derived(b: Base) : Base by b // Delegação para a classe BaseImpl
   

   No exemplo, Derived delega a implementação de Base ao objeto b.

2. Delegação de propriedades (Delegated Properties): Permite delegar a lógica de obtenção e definição do valor de uma propriedade a outro objeto. Kotlin fornece vários delegados padrão:

   • lazy() para inicialização diferida.

     val lazyValue: String by lazy {
         // Executa apenas na primeira referência a lazyValue
         println("a calcular!")
         "Olá"
     }
     

   • Delegates.observable() para notificar os ouvintes sobre mudanças.

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

   • Delegates.vetoable() para interceptar mudanças antes de aplicá-las.

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

   • Delegados para vincular às propriedades 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))

Vantagens do uso de delegação em Kotlin:

• Redução de código repetitivo: Redireciona automaticamente chamadas de métodos ou lógica de propriedades.
• Reutilização de código: Possibilidade de usar delegados existentes ou criar os seus próprios.
• Separação de responsabilidades: Divide claramente a lógica da propriedade ou interface.
• Flexibilidade: Permite alterar o comportamento da delegação sem modificar a classe.