Kotlin Academy · Lezione

Classi annidate

Classi all'interno di altre classi

Classi annidate è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Classi all'interno di classi

Kotlin consente di dichiarare una classe all'interno di un'altra classe. Per impostazione predefinita, questa classe è annidata e non mantiene un riferimento all'istanza esterna.

class Outer {
    class Nested {
        fun hello() = "Hi from Nested"
    }
}

fun main() {
    println(Outer.Nested().hello())
}

Creazione di un'istanza annidata

Poiché una classe annidata è indipendente, la si crea tramite il nome della classe esterna, senza un'istanza esterna: Outer.Nested().

class Computer {
    class Cpu {
        val cores = 8
    }
}

fun main() {
    val cpu = Computer.Cpu()
    println(cpu.cores)
}

Nessun accesso ai membri esterni

Una classe annidata non può accedere ai membri di istanza della classe esterna perché non dispone di un riferimento esterno. Si comporta come una classe di primo livello racchiusa in uno spazio dei nomi.

class Bank {
    val name = "ACME"
    class Branch {
        fun describe() = "A branch"
    }
}

fun main() {
    println(Bank.Branch().describe())
}

Perché usare classi annidate?

L'annidamento esprime un raggruppamento logico: il tipo interno appartiene concettualmente a quello esterno, migliorando l'organizzazione e la gestione degli spazi dei nomi.

class Http {
    class Request(val url: String)
}

fun main() {
    val r = Http.Request("/home")
    println(r.url)
}

Classe annidata con proprietà

Le classi annidate sono classi ordinarie: possono avere costruttori, proprietà e metodi.

class Garage {
    class Car(val model: String) {
        fun honk() = "$model: beep"
    }
}

fun main() {
    println(Garage.Car("Tesla").honk())
}

Accesso ai membri Companion o simili a statici

È possibile fare riferimento alle classi annidate da qualsiasi punto usando il nome della classe esterna, in modo simile a una classe annidata statica in Java.

class Config {
    class Defaults {
        val timeout = 30
    }
}

fun main() {
    println(Config.Defaults().timeout)
}

Più classi annidate

Una classe esterna può contenere diverse classi annidate per raggruppare tipi correlati.

class Shapes {
    class Circle(val r: Int)
    class Square(val side: Int)
}

fun main() {
    println(Shapes.Circle(5).r)
    println(Shapes.Square(4).side)
}

Annidamento all’interno di un’altra classe annidata

È possibile annidare le classi a più livelli, anche se un annidamento profondo può compromettere la leggibilità.

class A {
    class B {
        class C {
            val value = 42
        }
    }
}

fun main() {
    println(A.B.C().value)
}

Annidata o di primo livello

Dal punto di vista funzionale, una classe annidata è simile a una classe di primo livello; l’unica differenza è il suo nome qualificato. Scelga l’annidamento quando la relazione migliora la chiarezza.

class Order {
    class Item(val price: Int)
}

fun main() {
    val total = Order.Item(10).price + Order.Item(5).price
    println(total)
}

Un raggruppamento pratico

Raggruppare il tipo risultato di un builder sotto il relativo proprietario rende il codice naturale da leggere.

class Parser {
    class Result(val ok: Boolean, val message: String)

    fun parse(text: String) = Result(text.isNotEmpty(), "parsed")
}

fun main() {
    val res = Parser().parse("data")
    println("${res.ok} ${res.message}")
}

La regola fondamentale da ricordare

La parola chiave che fa sì che una classe conservi un riferimento alla classe esterna è inner. Senza di essa, una classe annidata è simile a una classe statica e isolata.

class Box {
    class Lid
}

fun main() {
    println(Box.Lid() != null)
}

Verifica rapida

Verifichi la sua comprensione delle classi annidate.

Riepilogo

Ha imparato a conoscere le classi annidate:

Dichiarate all’interno di un’altra classe, per impostazione predefinita sono class (annidate).
Non hanno un riferimento all’istanza esterna e non possono accedere ai membri esterni.
Vengono create tramite il nome della classe esterna: Outer.Nested().
Sono ottime per raggruppare logicamente gli elementi e creare namespace.

class Outer {
    class Nested { val x = 1 }
}

fun main() {
    println(Outer.Nested().x)
}

Domande Frequenti

La lezione «Classi annidate» è gratuita?

Sì — il testo completo di «Classi annidate» è 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 annidate»?

Classi all'interno di altre classi 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 1 di 4.

Quanto tempo richiede la lezione «Classi annidate»?

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