Kotlin Academy · Lección

Clases internas

Acceda al ámbito externo

Clases internas 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.

La palabra clave inner

Marcar una clase anidada con inner le proporciona una referencia a la instancia externa, por lo que puede acceder a los miembros de la clase externa.

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

Creación de una instancia interna

Como una clase interna necesita una instancia externa, debe crearla a partir de una: Outer().Inner().

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

Acceso a las propiedades externas

Una clase interna lee y utiliza directamente las propiedades externas, como si fueran propias.

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

Llamada a métodos externos

Las clases internas también pueden llamar a métodos de la instancia contenedora.

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

La sintaxis this@Outer

Para hacer referencia explícita a la instancia externa, por ejemplo cuando hay conflictos de nombres, utilice this@Outer.

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

¿Por qué utilizar inner?

Utilice inner cuando el tipo anidado realmente necesite colaborar con una instancia externa específica y compartir su estado.

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

Cada clase interna está vinculada a una clase externa

Una instancia interna está vinculada exactamente a la instancia externa que la creó; los cambios se reflejan en ese objeto.

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

Interna frente a anidada

Sin inner, una clase anidada está aislada. Con inner, captura la instancia externa. La palabra clave marca toda la diferencia.

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

Nota sobre la memoria

Como una instancia interna mantiene activa la instancia externa, tenga cuidado con los objetos internos de larga duración para evitar conservar accidentalmente el objeto externo.

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

Un iterador realista

Una clase interna es ideal para un iterador que recorre el estado de la colección que la contiene.

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

Combinación de conceptos

Las clases internas pueden utilizar el estado externo y desambiguar nombres con this@Outer.

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

Comprobación rápida

Compruebe su comprensión de las clases internas.

Resumen

Ha aprendido sobre las clases internas:

inner proporciona acceso a la instancia externa y a sus miembros.
Se crean mediante una instancia externa: Outer().Inner().
Utilice this@Outer para hacer referencia a la instancia contenedora.
Las instancias internas mantienen activa su instancia externa.

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

Preguntas frecuentes

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

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

Acceda al ámbito externo 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 «Clases internas»?

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