Objetos anónimos y expresiones de objeto
Use expresiones de objeto para crear implementaciones puntuales de interfaces.
Objetos anónimos y expresiones de objeto 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.
Expresiones object
Una expresión object crea una instancia anónima y única de una clase o interfaz: es el equivalente de Kotlin a las clases internas anónimas de Java, pero más potente.
Implementar una interfaz de forma anónima
Utilice object : Interface { ... } para crear una implementación en línea.
interface ClickListener {
fun onClick(): String
}
fun main() {
val listener = object : ClickListener {
override fun onClick() = "clicked!"
}
println(listener.onClick())
}Clase anónima con estado
Los objetos anónimos pueden contener estado y tener varios métodos.
fun main() {
val counter = object {
var count = 0
fun inc() { count++ }
fun show() = println("count = $count")
}
counter.inc(); counter.inc(); counter.inc()
counter.show()
}Tipo de un objeto anónimo
El tipo de un objeto anónimo se infiere. Cuando se declara en el nivel de una función, se mantiene el acceso a sus miembros personalizados.
fun main() {
val pair = object {
val left = "L"
val right = "R"
}
println("${pair.left} and ${pair.right}")
}Exposición del tipo anónimo
Si una función devuelve un objeto anónimo con un tipo inferido, los llamadores solo ven el supertipo; las adiciones anónimas no son accesibles externamente.
fun makeListener() = object {
fun greet() = "hello"
}
fun main() {
val l = makeListener()
println(l.greet()) // OK — same compilation unit
}Varias interfaces
Un objeto anónimo puede implementar varias interfaces en una sola expresión.
interface Closeable { fun close() }
interface Flushable { fun flush() }
fun main() {
val resource = object : Closeable, Flushable {
override fun close() = println("closed")
override fun flush() = println("flushed")
}
resource.flush()
resource.close()
}Extender una clase
Los objetos anónimos pueden extender una clase abierta y sobrescribir sus miembros.
open class Animal(val name: String) {
open fun speak() = "$name makes a sound"
}
fun main() {
val pet = object : Animal("Rex") {
override fun speak() = "$name barks!"
}
println(pet.speak())
}Capturar variables del contexto envolvente
Los objetos anónimos capturan las variables del ámbito envolvente, por lo que pueden leerlas y modificarlas, a diferencia de Java, que exige que sean final.
fun main() {
var log = mutableListOf<String>()
val recorder = object {
fun record(s: String) { log.add(s) }
}
recorder.record("event 1")
recorder.record("event 2")
println(log)
}Cuándo utilizar objetos anónimos
Utilice objetos anónimos para implementaciones únicas que no justifican tener su propia clase, normalmente callbacks, listeners o comparadores.
fun main() {
val nums = listOf(3, 1, 4, 1, 5, 9, 2, 6)
val sorted = nums.sortedWith(object : Comparator<Int> {
override fun compare(a: Int, b: Int) = b - a // descending
})
println(sorted)
}Prefiera lambdas cuando sea posible
Si la interfaz tiene un único método abstracto (SAM), una lambda resulta más limpia que una expresión object.
fun main() {
val nums = listOf(3, 1, 4, 1, 5, 9)
// Old way:
val sorted1 = nums.sortedWith(object : Comparator<Int> {
override fun compare(a: Int, b: Int) = b - a
})
// New way — SAM conversion:
val sorted2 = nums.sortedWith(Comparator { a, b -> b - a })
println("$sorted1 / $sorted2")
}Objeto anónimo frente a objeto declarado
Utilice object Name para un singleton con nombre. Utilice object : Type en una expresión para una instancia anónima y única.
// Named singleton (one instance, accessed globally)
object GlobalLogger { fun log(m: String) = println("[L] $m") }
// Anonymous (created at expression evaluation)
fun main() {
val local = object { fun hi() = "hi" }
GlobalLogger.log("hello")
println(local.hi())
}Comprobación rápida
¿Qué sintaxis crea en línea una instancia anónima que implementa una interfaz?
Resumen
Las expresiones object crean en línea instancias anónimas y únicas. Pueden implementar interfaces, extender clases, contener estado y capturar variables del contexto envolvente. Prefiera lambdas para interfaces de un solo método y utilice expresiones object cuando necesite varios métodos o estado.
Preguntas frecuentes
¿La lección «Objetos anónimos y expresiones de objeto» es gratis?
Sí — el texto completo de «Objetos anónimos y expresiones de objeto» 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 y expresiones de objeto»?
Use expresiones de objeto para crear implementaciones puntuales de interfaces. 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 y expresiones de objeto»?
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
- Declaración object: singletons de Kotlin
- companion object: miembros similares a los estáticos en Kotlin
- Objetos anónimos y expresiones de objeto
- Métodos de fábrica con companion object