Kotlin Academy · Lezione

Classi inner

Acceda allo scope esterno

Classi inner è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

La parola chiave inner

Contrassegnare una classe annidata con inner le assegna un riferimento all’istanza esterna, consentendole di accedere ai membri della classe esterna.

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

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

Creazione di un’istanza interna

Poiché una classe interna ha bisogno di un’istanza esterna, la si crea a partire da quest’ultima: Outer().Inner().

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

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

Accesso alle proprietà esterne

Una classe interna legge e utilizza direttamente le proprietà esterne, come se fossero proprie.

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

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

Chiamata dei metodi esterni

Le classi interne possono chiamare anche i metodi dell’istanza contenitore.

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

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

La sintassi this@Outer

Per fare riferimento esplicitamente all’istanza esterna, ad esempio quando i nomi entrano in conflitto, utilizzi this@Outer.

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

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

Perché usare inner?

Utilizzi inner quando il tipo annidato deve effettivamente collaborare con una specifica istanza esterna e condividerne lo stato.

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)
}

Ogni classe interna è associata a una sola classe esterna

Un’istanza interna è legata esattamente all’istanza esterna che l’ha creata; le modifiche vengono applicate a quell’oggetto.

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

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

Classe interna o annidata

Senza inner, una classe annidata è isolata. Con inner, acquisisce l’istanza esterna. La parola chiave fa tutta la differenza.

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

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

Nota sulla memoria

Poiché un’istanza interna mantiene in vita l’istanza esterna, presti attenzione agli oggetti interni di lunga durata per evitare di conservare involontariamente l’oggetto esterno.

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

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

Un iteratore realistico

Una classe interna è ideale per un iteratore che attraversa lo stato della raccolta che la contiene.

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

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

Combinazione dei concetti

Le classi interne possono utilizzare lo stato esterno e rimuovere le ambiguità con this@Outer.

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

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

Verifica rapida

Verifichi la sua comprensione delle classi interne.

Riepilogo

Ha imparato a conoscere le classi interne:

inner concede l’accesso all’istanza esterna e ai relativi membri.
Vengono create tramite un’istanza esterna: Outer().Inner().
Utilizzi this@Outer per fare riferimento all’istanza contenitore.
Le istanze interne mantengono in vita la propria istanza esterna.

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

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

Domande Frequenti

La lezione «Classi inner» è gratuita?

Sì — il testo completo di «Classi inner» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Classi inner»?

Acceda allo scope esterno Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Classi inner»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy