Kotlin Academy · Lección

Delegación a miembros

Componga comportamiento

Delegación a miembros es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Componer comportamiento

Los objetos reales a menudo necesitan combinar varias capacidades. En lugar de heredar de varias fuentes, puede delegar cada capacidad en un objeto miembro específico.

Dos funciones, una clase

Suponga que una clase debe leer y escribir. Defina dos interfaces y delegue cada una en su propia implementación.

interface Reader { fun read(): String }
interface Writer { fun write(s: String): String }

class FileReader : Reader { override fun read() = "contents" }
class FileWriter : Writer { override fun write(s: String) = "wrote " + s }

class FileIO(r: Reader, w: Writer) : Reader by r, Writer by w

fun main() {
    val io = FileIO(FileReader(), FileWriter())
    println(io.read())
    println(io.write("data"))
}

Varios delegados

Una clase puede delegar varias interfaces a la vez, cada una en un miembro diferente. La clase compone sus comportamientos sin herencia.

interface Logger { fun log(m: String): String }
interface Validator { fun valid(m: String): Boolean }

class ConsoleLogger : Logger { override fun log(m: String) = "LOG: " + m }
class LengthValidator : Validator { override fun valid(m: String) = m.isNotEmpty() }

class Service(l: Logger, v: Validator) : Logger by l, Validator by v

fun main() {
    val s = Service(ConsoleLogger(), LengthValidator())
    println(s.valid("hi"))
    println(s.log("started"))
}

Delegado almacenado como miembro

Cuando necesite hacer referencia al delegado dentro de las sobrescrituras, consérvelo como una propiedad del constructor. La misma instancia respalda tanto el reenvío como su código personalizado.

interface Cache { fun get(k: String): String }

class MapCache : Cache {
    override fun get(k: String) = "value-of-" + k
}

class TracingCache(private val inner: Cache) : Cache by inner {
    override fun get(k: String): String {
        println("lookup " + k)
        return inner.get(k)
    }
}

fun main() {
    println(TracingCache(MapCache()).get("id"))
}

Combinar delegación y estado propio

Una clase que delega puede añadir sus propias propiedades y métodos junto a los miembros reenviados, enriqueciendo el objeto compuesto.

interface Engine { fun start(): String }
class V8 : Engine { override fun start() = "vroom" }

class Car(e: Engine) : Engine by e {
    var doors = 4
    fun honk() = "beep"
}

fun main() {
    val c = Car(V8())
    println(c.start())
    println(c.honk())
    println(c.doors)
}

Intercambiar implementaciones

Como el delegado es simplemente un miembro, puede construir el mismo envoltorio con distintas implementaciones subyacentes y elegir el comportamiento en tiempo de ejecución.

interface Notifier { fun send(msg: String): String }
class EmailNotifier : Notifier { override fun send(msg: String) = "email: " + msg }
class SmsNotifier : Notifier { override fun send(msg: String) = "sms: " + msg }

class Alerts(n: Notifier) : Notifier by n

fun main() {
    println(Alerts(EmailNotifier()).send("hi"))
    println(Alerts(SmsNotifier()).send("hi"))
}

Delegar en una propiedad

La expresión posterior a by puede ser cualquier expresión que se evalúe una vez, incluida una llamada al constructor. No tiene que ser un parámetro.

interface Greeter { fun greet() = "hi" }
class DefaultGreeter : Greeter

class Page : Greeter by DefaultGreeter()

fun main() {
    println(Page().greet())
}

Evitar el problema del diamante

La herencia múltiple de comportamiento es imposible con clases, pero delegar varias interfaces en miembros independientes permite evitar limpiamente el clásico problema del diamante.

interface A { fun a() = "A" }
interface B { fun b() = "B" }
class AImpl : A
class BImpl : B

class Combined : A by AImpl(), B by BImpl()

fun main() {
    val c = Combined()
    println(c.a() + c.b())
}

Diseñar para la composición

Para componer correctamente:

Defina interfaces pequeñas y centradas
Proporcione implementaciones reutilizables
Delegue cada función en la clase que compone

Esto mantiene las clases flexibles y fáciles de probar.

Recapitulación de la delegación a miembros

Delegar en objetos miembros permite que una clase ensamble comportamiento a partir de varias piezas. Puede combinar muchas interfaces, sobrescribir de forma selectiva, intercambiar implementaciones y añadir su propio estado, todo sin herencia.

A continuación: una comparación directa

Ha visto lo flexible que es la delegación. La siguiente lección contrasta directamente la delegación con la herencia para que sepa cuándo elegir cada una.

Comprobación rápida

Compruebe su comprensión de la delegación a miembros.

Recapitulación

Ha aprendido la delegación a miembros:

Delegar varias interfaces en objetos independientes
Sobrescribir de forma selectiva y añadir estado propio
Intercambiar implementaciones durante la construcción
Evitar los problemas de la herencia múltiple

A continuación: delegación frente a herencia.

Preguntas frecuentes

¿La lección «Delegación a miembros» es gratis?

Sí — el texto completo de «Delegación a miembros» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Delegación a miembros»?

Componga comportamiento Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Delegación a miembros»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy