Kotlin Academy · Lección

Objetos anónimos

Implementaciones en línea

Objetos anónimos 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.

Implementaciones en línea

Un objeto anónimo crea una instancia de una clase o interfaz sin asignar un nombre a una clase nueva. Utilice la expresión object.

interface Greeter { fun greet(): String }

fun main() {
    val g = object : Greeter {
        override fun greet() = "Hi"
    }
    println(g.greet())
}

Implementación de una interfaz

Una expresión de objeto puede implementar una o varias interfaces justo donde se necesite.

interface Clickable { fun click() }

fun main() {
    val button = object : Clickable {
        override fun click() = println("Clicked")
    }
    button.click()
}

Sobrescritura de miembros de una clase

Puede crear una subclase anónima de una clase abierta y sobrescribir sus miembros.

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

fun main() {
    val cat = object : Animal() {
        override fun sound() = "Meow"
    }
    println(cat.sound())
}

Almacenamiento de estado adicional

Un objeto anónimo puede declarar sus propias propiedades además de las que sobrescribe.

fun main() {
    val point = object {
        val x = 3
        val y = 4
    }
    println("${point.x}, ${point.y}")
}

Objeto sin supertipo

Si omite el supertipo, el objeto es simplemente un conjunto ad hoc de miembros, útil para una agrupación local rápida.

fun main() {
    val config = object {
        val retries = 3
        val timeout = 30
    }
    println(config.retries)
}

Captura de variables locales

Los objetos anónimos pueden capturar variables del ámbito contenedor, a diferencia de las clases anidadas estáticas.

fun makeCounter(start: Int): () -> Int {
    var count = start
    val obj = object {
        fun next() = count++
    }
    return { obj.next() }
}

fun main() {
    val c = makeCounter(10)
    println(c())
    println(c())
}

Como listener

Un uso habitual consiste en pasar una implementación en línea como callback o listener.

interface OnDone { fun done(result: Int) }

fun compute(cb: OnDone) {
    cb.done(42)
}

fun main() {
    compute(object : OnDone {
        override fun done(result: Int) = println("Got $result")
    })
}

Tipo de un objeto anónimo

Cuando se devuelve desde una función, el tipo inferido es el supertipo declarado (o Any si no hay ninguno). Los miembros adicionales solo son visibles localmente.

interface Named { val name: String }

fun make(): Named = object : Named {
    override val name = "X"
}

fun main() {
    println(make().name)
}

Objetos anónimos frente a lambdas

Para las interfaces con un solo método, una lambda es más breve, pero se necesitan objetos anónimos cuando debe sobrescribir varios miembros o mantener estado.

interface Handler {
    fun onStart()
    fun onStop()
}

fun main() {
    val h = object : Handler {
        override fun onStart() = println("start")
        override fun onStop() = println("stop")
    }
    h.onStart()
    h.onStop()
}

Expresión de objeto frente a declaración de objeto

Una expresión de objeto crea una instancia nueva cada vez. Una declaración de objeto (object Name {}) es un singleton con nombre. Su aspecto es similar, pero su ciclo de vida es diferente.

object Singleton { val id = 1 }

fun main() {
    val fresh = object { val id = 2 }
    println(Singleton.id)
    println(fresh.id)
}

Un comparador compacto

Los objetos anónimos resultan prácticos para comparadores o estrategias de un solo uso.

fun main() {
    val cmp = object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    }
    val list = listOf(1, 3, 2).sortedWith(cmp)
    println(list)
}

Comprobación rápida

Compruebe su comprensión de los objetos anónimos.

Resumen

Ha aprendido sobre los objetos anónimos:

La expresión object : Type {} crea una instancia sin nombre.
Pueden implementar interfaces, crear subclases de clases abiertas y mantener estado.
Capturan las variables locales del ámbito contenedor.
Utilícelos para callbacks con varios métodos; prefiera lambdas para métodos individuales.

interface Run { fun go() }

fun main() {
    val r = object : Run { override fun go() = println("go") }
    r.go()
}

Preguntas frecuentes

¿La lección «Objetos anónimos» es gratis?

Sí — el texto completo de «Objetos anónimos» 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 «Objetos anónimos»?

Implementaciones en línea 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 «Objetos anónimos»?

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