Kotlin Academy · Lección

Delegación frente a herencia

Elija la composición

Delegación frente a herencia es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 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.

Dos formas de reutilizar

La herencia y la delegación reutilizan el comportamiento. La herencia indica que una clase es una clase de otro tipo. La delegación indica que una clase tiene un colaborador al que reenvía las llamadas.

El consejo clásico: prefiera la composición a la herencia.

Ejemplo de herencia

Con la herencia, una subclase extiende una clase base y sobrescribe miembros. En Kotlin, la clase base debe ser open.

open class Animal {
    open fun sound() = "..."
}

class Dog : Animal() {
    override fun sound() = "woof"
}

fun main() {
    println(Dog().sound())
}

Ejemplo de delegación

La misma reutilización mediante delegación: el comportamiento reside en un miembro al que la clase reenvía las llamadas.

interface Sound { fun sound(): String }
class Bark : Sound { override fun sound() = "woof" }

class Dog(s: Sound) : Sound by s

fun main() {
    println(Dog(Bark()).sound())
}

La clase base frágil

La herencia acopla estrechamente una subclase a los detalles internos de su clase padre. Un cambio en la clase base puede romper silenciosamente las subclases: es el problema de la clase base frágil. La delegación solo depende de la interfaz.

Encapsulación

Una subclase puede acceder a miembros protegidos y sobrescribir métodos de extensión, examinando el interior de la clase padre. Una clase que delega solo ve la interfaz pública, lo que preserva la encapsulación.

interface Counter { fun increment(): Int }

class SimpleCounter : Counter {
    private var n = 0
    override fun increment(): Int { n++; return n }
}

class GuardedCounter(private val c: Counter) : Counter by c {
    override fun increment(): Int {
        println("incrementing")
        return c.increment()
    }
}

fun main() {
    val g = GuardedCounter(SimpleCounter())
    println(g.increment())
    println(g.increment())
}

Flexibilidad en tiempo de ejecución

La herencia fija la clase padre en tiempo de compilación. La delegación permite inyectar distintas implementaciones en tiempo de ejecución, lo que facilita las pruebas con objetos simulados.

interface Clock { fun now(): Int }
class RealClock : Clock { override fun now() = 100 }
class FakeClock : Clock { override fun now() = 0 }

class Timer(c: Clock) : Clock by c

fun main() {
    println(Timer(RealClock()).now())
    println(Timer(FakeClock()).now()) // easy to test
}

Múltiples comportamientos

Una clase solo puede extender una clase padre, pero puede delegar en muchas interfaces. La delegación permite combinar varias capacidades de forma escalable.

interface Walk { fun walk() = "walking" }
interface Swim { fun swim() = "swimming" }
class Walker : Walk
class Swimmer : Swim

class Amphibian : Walk by Walker(), Swim by Swimmer()

fun main() {
    val a = Amphibian()
    println(a.walk() + ", " + a.swim())
}

Cuándo encaja la herencia

La herencia sigue siendo adecuada para una relación auténtica de es-un con una jerarquía estable y diseñada para la extensión: familias de tipos selladas, clases base de frameworks y polimorfismo sobre un tipo abstracto compartido.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape) = when (shape) {
    is Circle -> 3.14 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Circle(2.0)))
}

Cuándo encaja la delegación

Elija la delegación cuando quiera:

Reutilizar comportamiento entre tipos no relacionados
Combinar varias capacidades
Mantener un acoplamiento bajo y facilitar las pruebas
Envolver y decorar implementaciones existentes

Comparación lado a lado

Herencia: una clase padre, acoplamiento estrecho, fija en tiempo de compilación, es-un. Delegación: muchos colaboradores, acoplamiento débil, intercambiable en tiempo de ejecución, tiene-un. Kotlin hace que la delegación sea sencilla con by, inclinando la balanza hacia la composición.

Una buena opción predeterminada

Una buena regla es empezar con la delegación. Cambie a la herencia solo cuando surja una jerarquía genuina y estable de es-un. Así mantendrá los diseños flexibles y resistentes a los cambios.

Comprobación rápida

Compruebe su comprensión de la delegación frente a la herencia.

Resumen

Ha comparado los dos enfoques:

Herencia: es-un, una sola clase padre, acoplamiento estrecho
Delegación: tiene-un, muchos colaboradores, acoplamiento débil
Prefiera la composición; use la herencia para jerarquías estables de tipo es-un

A continuación: patrones prácticos de decorador con delegación.

Preguntas frecuentes

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

Sí — el texto completo de «Delegación frente a herencia» 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 frente a herencia»?

Elija la composición 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 3 de 4.

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

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