Kotlin - Delegação

Suporta Kotlin “delegation” padrão de design, introduzindo uma nova palavra-chave “by”. Usando essa palavra-chave ou metodologia de delegação, Kotlin permite que a classe derivada acesse todos os métodos públicos implementados de uma interface por meio de um objeto específico. O exemplo a seguir demonstra como isso acontece em Kotlin.

interface Base {
   fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
   override fun printMe() { println(x) }   //implementation of the method
}
class Derived(b: Base) : Base by b  // delegating the public method on the object b

fun main(args: Array<String>) {
   val b = BaseImpl(10)
   Derived(b).printMe() // prints 10 :: accessing the printMe() method 
}

No exemplo, temos uma interface “Base” com seu método abstrato denominado “printme ()”. Na classe BaseImpl, estamos implementando este “printme ()” e mais tarde de outra classe estamos usando esta implementação usando a palavra-chave “by”.

O trecho de código acima produzirá a seguinte saída no navegador.

10

Delegação de propriedade

Na seção anterior, aprendemos sobre o padrão de design de delegação usando a palavra-chave “por”. Nesta seção, aprenderemos sobre delegação de propriedades usando alguns métodos padrão mencionados na biblioteca Kotlin.

Delegar significa passar a responsabilidade para outra classe ou método. Quando uma propriedade já está declarada em alguns lugares, devemos reutilizar o mesmo código para inicializá-los. Nos exemplos a seguir, usaremos alguma metodologia de delegação padrão fornecida por Kotlin e algumas funções de biblioteca padrão ao implementar a delegação em nossos exemplos.

Usando Lazy ()

Lazy é uma função lambda que recebe uma propriedade como entrada e, em troca, fornece uma instância de Lazy<T>, onde <T> é basicamente o tipo das propriedades que está usando. Vamos dar uma olhada no seguinte para entender como funciona.

val myVar: String by lazy {
   "Hello"
}
fun main(args: Array<String>) {
   println(myVar +" My dear friend")
}

No trecho de código acima, estamos passando uma variável “myVar” para a função Lazy, que em retorno atribui o valor ao seu objeto e retorna o mesmo para a função principal. A seguir está a saída no navegador.

Hello My dear friend

Delegetion.Observable ()

Observable () recebe dois argumentos para inicializar o objeto e retorna o mesmo para a função chamada. No exemplo a seguir, veremos como usar o método Observable () para implementar a delegação.

import kotlin.properties.Delegates
class User {
   var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
      prop, old, new ->
      println("$old -> $new")
   }
}
fun main(args: Array<String>) {
   val user = User()
   user.name = "first"
   user.name = "second"
}

O trecho de código acima produzirá a seguinte saída no navegador.

first -> second

Em geral, a sintaxe é a expressão após a palavra-chave “por” ser delegada. oget() e set() métodos da variável p será delegado ao seu getValue() e setValue() métodos definidos na classe Delegate.

class Example {
   var p: String by Delegate()
}

Para o trecho de código acima, a seguir está a classe delegada que precisamos gerar para atribuir o valor na variável p.

class Delegate {
   operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
      return "$thisRef, thank you for delegating '${property.name}' to me!"
   }
   operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
      println("$value has been assigned to '${property.name} in $thisRef.'")
   }
}

Durante a leitura, o método getValue () será chamado e, durante a configuração da variável, o método setValue () será chamado.