Android Academy · Lezione

Tipi nullable e non-null a confronto

Il marcatore di tipo ?.

Tipi nullable e non-null a confronto è una lezione Android 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 Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.

Perché la null safety è importante

Molti arresti anomali nelle app Android derivano da un unico errore: utilizzare un valore che in realtà manca. In altri linguaggi questo provoca a runtime la temuta NullPointerException.

Kotlin affronta il problema in fase di compilazione. Il sistema dei tipi tiene traccia dei valori che possono essere null e di quelli che non possono mai esserlo. Questa lezione introduce le basi di tale sistema.

Tipi non null

Per impostazione predefinita, un tipo Kotlin non può contenere null. Una String fa sempre riferimento a una stringa reale.

Se prova ad assegnarle null, il codice non verrà nemmeno compilato. Questa è l'impostazione sicura predefinita.

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

Null viene rifiutato

Osservi cosa succede quando prova a inserire null in un tipo non null.

Il compilatore La blocca immediatamente. Non arriverà mai a runtime con un errore nascosto.

val name: String = null  // Compile error:
// Null can not be a value of a non-null type String

Tipi nullable con ?

A volte un valore può davvero mancare, ad esempio il secondo nome facoltativo di un utente. Per indicarlo, aggiunga ? al tipo.

Una String? può contenere una stringa reale oppure null. Il punto interrogativo indica che il tipo è nullable.

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

Due tipi diversi

String e String? non sono lo stesso tipo. Il secondo è un tipo più ampio che include il valore null.

È questa distinzione che consente al compilatore di proteggerLa. Sa esattamente dove può comparire null.

val sure: String = "hello"
val maybe: String? = "hello"
// maybe could later be null; sure never can

Non può usare direttamente un tipo nullable

Il compilatore non Le permette di chiamare un metodo su un valore nullable senza averlo prima verificato.

Poiché middleName potrebbe essere null, chiamare .length su di esso genera un errore di compilazione. Deve gestire il caso null.

val middleName: String? = null
println(middleName.length)
// Error: only safe (?.) or non-null (!!) calls allowed

Verificare con if

Il modo più semplice per utilizzare un valore nullable consiste nel verificarlo con una condizione if.

All'interno del ramo in cui ha dimostrato che non è null, Kotlin applica automaticamente uno smart cast a un tipo non null, quindi .length funziona.

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

Smart cast

Dopo un controllo null riuscito, il compilatore ricorda che il valore non è null per il resto del blocco. Questo si chiama smart cast.

Non ha scritto alcuna conversione. Kotlin l'ha gestita automaticamente per Lei.

fun describe(s: String?) {
    if (s == null) return
    // s is now treated as String here
    println("Length is " + s.length)
}

Parametri delle funzioni

Stabilire se un parametro è nullable fa parte del contratto della funzione. Un parametro non null garantisce ai chiamanti che non riceverà mai null.

Un parametro nullable segnala che un input mancante è previsto e viene gestito.

fun greet(name: String) {
    println("Hi, " + name)
}
// greet(null) would not compile

I tipi restituiti possono essere nullable

Una funzione può restituire null per segnalare che non è stato trovato nulla. Indichi ? nel tipo restituito.

In questo modo i chiamanti sanno di dover verificare il risultato prima di utilizzarlo.

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

Preferire i tipi non null

Una buona regola è preferire i tipi non null. Aggiunga ? solo quando un valore può davvero essere assente.

In questo modo il codice rispecchia meglio la realtà. Meno tipi nullable utilizza, meno controlli null dovrà eseguire in seguito.

// Prefer this:
val score: Int = 0
// Over this, unless null is meaningful:
val maybeScore: Int? = null

Verifica rapida

Verifichi la Sua comprensione dei tipi nullable e non null.

Riepilogo

Per impostazione predefinita, i tipi Kotlin sono non null e rifiutano null in fase di compilazione. Aggiunga ? per rendere un tipo nullable quando un valore può mancare.

Non può utilizzare direttamente un valore nullable. Un controllo null applica uno smart cast a non null, consentendo di usarlo in sicurezza. In seguito imparerà modi più brevi per gestire i valori nullable.

Domande Frequenti

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

Sì — il testo completo di «Tipi nullable e non-null a confronto» è 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 Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Tipi nullable e non-null a confronto»?

Il marcatore di tipo ?. Eserciti Android 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 Android Academy?

Non è richiesta alcuna esperienza precedente. Android 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 a confronto»?

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 Android Academy?

Sì. Ogni lezione Android 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 Android Academy