Kotlin Academy · Lezione

Tipi nullable e non-null

Le basi del sistema dei tipi

Tipi nullable e non-null è 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.

Perché la null safety è importante

Il famigerato NullPointerException ha causato il crash di innumerevoli programmi. Kotlin affronta il problema alla radice rendendo la nullabilità parte del sistema dei tipi.

In Kotlin, il compilatore sa se un valore può essere null oppure no e obbliga a gestire questa possibilità prima che causi problemi.

Tipi non nullable

Per impostazione predefinita, ogni tipo in Kotlin è non nullable. Una variabile di tipo String non può mai contenere null.

Questa garanzia viene verificata in fase di compilazione, quindi è possibile utilizzare liberamente il valore senza controlli.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

L'assegnazione di null viene rifiutata

Se prova a inserire null in un tipo non nullable, il compilatore si arresta immediatamente.

La riga seguente non verrebbe compilata perché String non accetta null:

val name: String = null → errore

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Tipi nullable

Per consentire null, aggiunga un punto interrogativo dopo il tipo: String?.

Questo è un tipo nullable. Può contenere un valore reale oppure null.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Nullable e non nullable

Le due dichiarazioni sono quasi identiche, ma si comportano in modo molto diverso:

val a: String → non è mai null
val b: String? → potrebbe essere null

Il singolo ? cambia l'intero contratto della variabile.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

Il compilatore protegge l'accesso ai nullable

Non è possibile chiamare direttamente metodi su un valore nullable. Il compilatore lo impedisce perché il valore potrebbe essere null.

La riga commentata seguente non verrebbe compilata:

maybe.length su un String? → errore

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Controllare la presenza di null

Un modo semplice per utilizzare un valore nullable consiste nell'eseguire un controllo esplicito con if.

All'interno del blocco if, Kotlin sa che il valore non è null e consente di utilizzarlo in sicurezza.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

Null nei parametri delle funzioni

Anche i tipi dei parametri seguono questa regola. Un parametro di tipo String deve ricevere un valore reale, mentre String? accetta null.

In questo modo, le firme delle funzioni documentano autonomamente i valori accettati.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Tipi restituiti nullable

Le funzioni possono restituire tipi nullable per indicare che il risultato potrebbe non essere disponibile.

Chi chiama la funzione è quindi obbligato a gestire l'eventuale null prima di utilizzare il risultato.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Inferenza automatica

Quando assegna un valore letterale, Kotlin deduce automaticamente un tipo non nullable.

val n = "text" → viene dedotto String

Per renderlo nullable, deve dichiarare esplicitamente il tipo con ?.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Mettere tutto insieme

Il sistema dei tipi divide i valori in due gruppi chiari:

Non nullable: sempre sicuri da utilizzare
Nullable: devono essere gestiti prima dell'utilizzo

Questa distinzione trasforma i bug causati da null da crash a runtime in errori in fase di compilazione.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Verifica rapida

Verifichi la comprensione dei tipi nullable e non nullable.

Riepilogo

Ha appreso i fondamenti della null safety di Kotlin:

Ogni tipo è non nullable per impostazione predefinita
L'aggiunta di ? crea un tipo nullable
Il compilatore impedisce l'accesso non sicuro ai valori nullable
Un controllo if (x != null) consente di utilizzare il valore in sicurezza

Successivamente imparerà a utilizzare gli operatori concisi che rendono semplice lavorare con i nullable.

Domande Frequenti

La lezione «Tipi nullable e non-null» è gratuita?

Sì — il testo completo di «Tipi nullable e non-null» è 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 «Tipi nullable e non-null»?

Le basi del sistema dei tipi 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 «Tipi nullable e non-null»?

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