Kotlin Academy · Lección

Clases locales

Clases dentro de funciones

Clases locales es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.

Clases dentro de funciones

Kotlin permite declarar una clase local dentro del cuerpo de una función. Solo está visible dentro de esa función.

fun main() {
    class Greeting(val text: String) {
        fun show() = println(text)
    }
    Greeting("Hello local").show()
}

Limitada al ámbito de la función

Una clase local no puede utilizarse fuera de la función en la que se declara, lo que mantiene los tipos auxiliares perfectamente contenidos.

fun build(): String {
    class Builder {
        fun make() = "built"
    }
    return Builder().make()
}

fun main() {
    println(build())
}

Captura de variables locales

Al igual que las clausuras, las clases locales pueden capturar variables de la función contenedora.

fun main() {
    val prefix = ">> "
    class Logger {
        fun log(msg: String) = println(prefix + msg)
    }
    Logger().log("started")
}

Varias instancias

Puede crear tantas instancias de una clase local como desee dentro de la función.

fun main() {
    class Point(val x: Int)
    val a = Point(1)
    val b = Point(2)
    println(a.x + b.x)
}

Clase local con métodos

Las clases locales son clases completas: los constructores, las propiedades y los métodos funcionan con normalidad.

fun main() {
    class Account(var balance: Int) {
        fun deposit(n: Int) { balance += n }
    }
    val acc = Account(100)
    acc.deposit(50)
    println(acc.balance)
}

¿Por qué utilizar una clase local?

Utilícela cuando un tipo auxiliar solo tenga sentido dentro de una función, para evitar llenar el archivo de tipos de nivel superior.

fun parseLine(line: String): Int {
    class Token(val value: String)
    val tokens = line.split(",").map { Token(it) }
    return tokens.size
}

fun main() {
    println(parseLine("a,b,c"))
}

Captura de estado mutable

Una clase local puede modificar variables mutables capturadas de su ámbito contenedor.

fun main() {
    var total = 0
    class Adder {
        fun add(n: Int) { total += n }
    }
    val a = Adder()
    a.add(5)
    a.add(7)
    println(total)
}

Implementación local de interfaces

Las clases locales pueden implementar interfaces, lo que resulta útil cuando necesita una implementación con nombre y reutilizable dentro de una función.

interface Step { fun run(): String }

fun main() {
    class First : Step {
        override fun run() = "first"
    }
    println(First().run())
}

Local frente a anónima

Elija una clase local cuando necesite un nombre, para crear varias instancias o hacer referencia al tipo. Elija un objeto anónimo para una única instancia en línea.

fun main() {
    class Repeater(val times: Int) {
        fun run() = "x".repeat(times)
    }
    println(Repeater(3).run())
}

Anidamiento dentro de bucles

Incluso puede declarar una clase local dentro de bloques como los bucles; su ámbito se limita a ese bloque.

fun main() {
    for (i in 1..2) {
        class Tag(val id: Int)
        println(Tag(i).id)
    }
}

Un auxiliar práctico

Las clases locales son ideales para auxiliares de dominio de corta duración utilizados exactamente por una función.

fun report(values: List<Int>): String {
    class Stats(val sum: Int, val max: Int)
    val s = Stats(values.sum(), values.max())
    return "sum=${s.sum} max=${s.max}"
}

fun main() {
    println(report(listOf(3, 7, 2)))
}

Comprobación rápida

Compruebe su comprensión de las clases locales.

Resumen

Ha aprendido sobre las clases locales:

Se declaran dentro de una función y su ámbito se limita a ella.
Pueden capturar y modificar variables locales contenedoras.
Son clases completas: constructores, propiedades, métodos e interfaces.
Utilice una clase local cuando necesite un nombre; un objeto anónimo, para una única instancia en línea.

fun main() {
    val tag = "L"
    class C { fun show() = tag }
    println(C().show())
}

Preguntas frecuentes

¿La lección «Clases locales» es gratis?

Sí — el texto completo de «Clases locales» 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 «Clases locales»?

Clases dentro de funciones 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 4 de 4.

¿Cuánto tiempo toma la lección «Clases locales»?

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