Android Academy · Lezione

Evitare le NullPointerException

Pattern per scrivere codice sicuro.

Evitare le NullPointerException è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 4 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.

L'obiettivo: nessuna NPE

Una NullPointerException, o NPE, si verifica quando il codice usa qualcosa che in realtà è null. Kotlin è progettato per rendere questi casi rari.

Questa lezione riunisce gli strumenti appresi e illustra i pochi modi in cui una NPE può ancora verificarsi.

L'operatore !!

L'asserzione di non nullità !! dice al compilatore di fidarsi del fatto che un valore non sia null. Se l'asserzione è errata, viene lanciata una NPE.

Questo operatore elimina la sicurezza, quindi lo usi raramente e solo quando ne è certo.

fun main() {
    val name: String? = "Ada"
    println(name!!.length)  // works, name is not null
}

!! può causare un crash

Se il valore è effettivamente null, !! lancia una NullPointerException esattamente in quella riga.

Questo è il modo principale per reintrodurre proprio il problema che Kotlin previene. Eviti !! quando sarebbe sufficiente una safe call o Elvis.

val name: String? = null
println(name!!.length)
// throws KotlinNullPointerException

Preferire alternative sicure

Quasi ogni uso di !! può essere riscritto con ?. e ?:. La versione sicura non può causare un crash.

Confronti di seguito la forma rischiosa con quella sicura.

// Risky:
val len1 = name!!.length
// Safe:
val len2 = name?.length ?: 0

Convalidare in anticipo

Gestisca i valori null ai confini del codice, poi lavori con valori non null all'interno. Usi Elvis con return o throw per rifiutare subito gli input mancanti.

Dopo il controllo, il valore viene sottoposto a smart cast come non null.

fun length(s: String?): Int {
    val text = s ?: return 0
    return text.length
}

requireNotNull

Quando null indica realmente un bug, requireNotNull lancia un errore chiaro e restituisce il valore non null.

È più descrittivo di !! perché consente di aggiungere un messaggio.

fun start(config: String?) {
    val c = requireNotNull(config) { "config missing" }
    println(c.length)
}

Platform type da Java

I valori provenienti da Java hanno una nullability sconosciuta e sono chiamati platform type. Kotlin non può garantire che siano non null.

Quando usa librerie Java, dichiari esplicitamente il tipo previsto e gestisca i valori null in modo prudente.

// From Java: String maybe = obj.getName();
val name: String? = obj.name  // be safe
println(name?.length ?: 0)

Il rischio di lateinit

Una lateinit var consente di rimandare l'inizializzazione di una proprietà non null. Tuttavia, usarla prima dell'assegnazione lancia un'eccezione.

Usi lateinit solo quando è certo che il valore sia impostato prima di qualsiasi accesso.

lateinit var config: String
fun read() {
    println(config.length)
    // crashes if config was never set
}

Valori predefiniti invece di null

Spesso è possibile evitare del tutto la nullability scegliendo un valore predefinito sensato. Una stringa vuota o una lista vuota sono spesso preferibili a null.

Meno tipi nullable significano meno possibilità di una NPE.

fun main() {
    val tags: List<String> = emptyList()
    println(tags.size)  // 0, never null
}

Una pipeline sicura

Questo programma legge un valore opzionale, lo trasforma in modo sicuro e produce sempre un risultato. Nessun !!, nessun crash.

Questo è lo stile a cui aspirare nel codice Android reale.

fun main() {
    val input: String? = null
    val result = input?.trim()?.uppercase() ?: "N/A"
    println(result)  // prints: N/A
}

Buone pratiche

Preferisca i tipi non null, gestisca i valori null ai confini con Elvis e usi ?.let per le azioni opzionali. Riservi !! ai rari casi in cui null è impossibile.

Seguendo queste abitudini, le NullPointerException diventeranno un ricordo del passato.

val safe = data?.value ?: default
data?.let { handle(it) }

Verifica rapida

Verifichi la comprensione di come evitare le NullPointerException.

Riepilogo

In Kotlin, le NPE derivano solitamente da !!, dai platform type provenienti da Java o da valori lateinit non inizializzati. Le eviti preferendo i tipi non null e gli operatori sicuri.

Usi ?., ?:, ?.let e la convalida come requireNotNull per mantenere il codice privo di crash. Ha completato i concetti essenziali della null safety in Kotlin.

Domande Frequenti

La lezione «Evitare le NullPointerException» è gratuita?

Sì — il testo completo di «Evitare le NullPointerException» è 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 «Evitare le NullPointerException»?

Pattern per scrivere codice sicuro. 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 4 di 4.

Quanto tempo richiede la lezione «Evitare le NullPointerException»?

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