Propiedades delegadas en Kotlin

La delegación se define como el otorgamiento de cualquier autoridad o poder a otra persona (Jefe asignando tareas a sus empleados) para llevar a cabo un trabajo diferente. Sin embargo, la persona que delegó el trabajo sigue siendo responsable del resultado del trabajo delegado. De manera similar, hay varios tipos de propiedades en un lenguaje de programación que podemos implementar manualmente cada vez que queramos usarlos para delegar otro trabajo de código y podemos implementarlos de una vez por todas y ponerlos en la biblioteca si se usan continuamente en nuestro programa.

Clasificación

Hay principalmente 3 tipos de propiedades utilizadas para la delegación:

1. Propiedades perezosas: Lazy es una función lambda que toma la propiedad para implementar la entrada y devolver una instancia de Lazy donde T denota el tipo de propiedad que se usa para implementar la propiedad perezosa. De forma predeterminada, lazy está sincronizado significa que el valor se calcula en la primera llamada y el mismo valor también se devolverá en otras llamadas, podemos detener la sincronización usando LazyThreadSafetyMode.PUBLICATION como parámetro de la función. 

Ejemplo:

// Defining an immutable variable in kotlin
val lazyValue: String by lazy
{
  // Printing to standard output
  println("GeeksforGeeks")
  "GeeksforGeeks"
}
 
fun main()
{
  // Printing Var lazyValue values to standardoutput
  println(lazyValue)
  println(lazyValue)
}

Producción:

GeeksforGeeks
GeeksforGeeks
GeeksforGeeks

Explicación:

Aquí, el valor se calcula solo en «println», e println llama a lazyValue y el valor en println se imprime como salida y todas las devoluciones de llamada verán el mismo valor debido a la sincronización.

2. Propiedades observables: notifica al usuario sobre los cambios realizados en la clase utilizando el controlador que contiene información sobre los cambios que se están produciendo. Se utiliza para recibir notificaciones a través de devoluciones de llamada cada vez que cambia la propiedad. Contiene dos argumentos para inicializar el objeto, nueva propiedad o valor (el valor inicial) y un controlador que contiene información sobre todas las modificaciones que haremos al asignar la entrada al objeto (contiene una propiedad para asignar, valor antiguo, el nuevo valor asignado).

Ejemplo:

import kotlin.properties.Delegates
 
class Myself
{
  // Creating a Myself Class with String variable name
  var name: String by Delegates.observable("company name")
  {
    // default Previous value "company name"
    prop, old, new ->
    println("$old -> $new") // Old value is being
                             // assigned a new value
  }
}
 
fun main()
{
  // Assigning name variable default value
  val V1 = Myself()
   
  // Assigning name variable a new value "Previous to"
  V1.name = "Previous to"
   
  // Now again changing "Previous to " to "New Value" value
  V1.name = "New Value"
}

Producción: 

company name -> Previous to
Previous to -> New Value

Explicación:
Aquí las propiedades observables toman dos argumentos, el valor inicial como “nombre de la empresa” y segundo el handler al cual llamamos cada vez que le asignamos a la propiedad con tres valores como “propiedad a modificar, el valor anterior y el valor nuevo .

3. Vetable: Nos permite modificar los valores cuando el argumento ingresado por el (los) usuario (s) cumple la condición especificada, se puede usar en lugar de las propiedades observables si el usuario desea interceptar la asignación. Vetoable es como las propiedades observables con características adicionales que permiten modificar y notificar los valores cuando se cumple la condición.

Ejemplo: 

var max: Int by Delegates.vetoable(0)
{
  // Defining variable max with vetoable default value as 0
  property, oldValue, newValue ->
  newValue > oldValue
}
 
// printing value of max valriable default zero
println(max)
 
// assigning new value to max variable
max = 10
 
// printing newly assigned value to max variable
println(max)
 
// assigning new value to max variable but it
// doesnot satisfy max condition
max = 5
 
println(max)

Producción: 

0
10
10

Explicación:

En primer lugar, se imprime el valor predeterminado y luego, se asigna el nuevo valor máximo y el valor no se cambió cuando se invocó nuevamente la devolución de llamada anterior debido a que no se cumplió con la propiedad. Cuando la devolución de llamada devuelve verdadero, significa que el valor de la propiedad se cambia a un nuevo valor; de lo contrario, el nuevo valor se descarta y la propiedad aún contiene su valor antiguo (anterior).

4. Almacenamiento de propiedades en un mapa: este método se utiliza para almacenar propiedades en una función de mapa y utilizarlas para aplicaciones dinámicas. 

Ejemplo: 

class Myself(val map: Map<String, Any?>)
{
  // defining class Myself
  val my_name: String by map // Variable my_name
  val my_age: Int     by map // Variable my_age
}
 
// calling Myself class using map function and
// assigning value to my_name and my_age variables
fun main()
{
  val V1 = Myself(mapOf(
        "my_name" to "GeeksforGeeks",
        "my_age"  to 50))
   
  // Printing value of my_name variable
  println(V1.my_name)
   
  // Printing value of my_age variable
  println(V1.my_age) 
}

Producción:

GeeksforGeeks
50

Esto también funciona para las propiedades de var si usa un mapa mutable en lugar de un mapa de solo lectura

Explicación:
aquí creamos una clase Myself, que contiene una función de mapa, para aceptar la entrada en forma de string o cualquiera (int, float, string, etc.) y almacenarlos en las variables my_name y my_age en la función de mapa dentro de mi clase y podemos use la función de mapa dinámicamente dentro de cualquier clase recién creada también.