NullPointerException in Java: cause e come risolverla

L'errore più comune in Java

Una NullPointerException (tutti la chiamano NPE) si verifica quando provi a usare un riferimento che non punta a niente, cioè null, come se puntasse a un oggetto vero. In Java le variabili di tipo oggetto contengono un oggetto oppure null, il valore che significa "qui non c'è nessun oggetto". Nel momento in cui chiedi a null di fare qualcosa (chiamare un suo metodo, leggere un suo campo, accedere a un indice) non c'è niente su cui agire, quindi la JVM lancia l'eccezione.

A differenza di try-catch, che hai visto nella pagina precedente per gestire errori previsti, una NPE è quasi sempre un semplice bug. Lo scopo di questa pagina non è catturarle: è capire perché si verificano e scrivere codice che non le produca.

public class Main {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length());  // bum: name è null
    }
}

Non c'è nessuna String su cui eseguire length(), quindi il programma si ferma con una NullPointerException.

Leggere il messaggio

Da Java 14 il messaggio ti dice esattamente cosa era null: si chiama Helpful NullPointerException. Leggilo prima di cambiare qualsiasi cosa:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null
	at Main.main(Main.java:4)

Contano due parti. Cannot invoke "String.length()" è l'operazione che è fallita, e because "name" is null indica il colpevole. La riga at Main.main(Main.java:4) è lo stack trace che punta alla riga esatta. Quindi la soluzione non è "metti la riga 4 in un try", ma "scopri perché name è null alla riga 4". Quasi sempre il bug si trova più in alto, dove il valore avrebbe dovuto essere assegnato e non lo è stato.

I modi in cui la provochi

Le NPE nascono da poche operazioni, tutte varianti di "toccare null":

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 1. Chiamare un metodo su null
        String s = null;
        // System.out.println(s.toUpperCase());  // NPE

        // 2. Una ricerca nella mappa che non trova niente restituisce null
        Map<String, Integer> ages = new HashMap<>();
        Integer age = ages.get("Ada");   // la chiave non esiste -> null
        System.out.println("Lookup returned: " + age);

        // 3. Fare unboxing di un wrapper null in un primitivo
        // int n = age;   // NPE: impossibile fare unboxing di un Integer null in int

        System.out.println("Reached the end safely");
    }
}

Le ricerche nelle mappe sono una fonte classica: get restituisce null quando la chiave non c'è, e la NPE spesso compare molte righe dopo, quando finalmente usi quel valore. L'unboxing è il caso più subdolo: assegnare un Integer che vale null a un int lancia l'eccezione, perché non c'è nessun numero da copiare.

Proteggersi con un controllo su null

La difesa più semplice è un if che verifica che un riferimento non sia null prima di usarlo:

public class Main {
    public static void main(String[] args) {
        String name = lookupName(7);

        if (name != null) {
            System.out.println(name.toUpperCase());
        } else {
            System.out.println("No name found");
        }
    }

    static String lookupName(int id) {
        return null;  // fingiamo che la ricerca non abbia trovato niente
    }
}

Quando confronti una variabile con una String costante, metti prima la costante: "yes".equals(answer) invece di answer.equals("yes"). Se answer è null, la prima forma restituisce tranquillamente false, mentre la seconda lancia l'eccezione.

public class Main {
    public static void main(String[] args) {
        String answer = null;

        // Sicuro anche quando answer è null:
        System.out.println("yes".equals(answer));   // false, nessuna NPE

        // answer.equals("yes") qui lancerebbe una NullPointerException
    }
}

Fallire subito con Objects.requireNonNull

Spargere controlli su null ovunque rende il codice rumoroso. Quando un valore non dovrebbe mai essere null, come l'argomento di un costruttore, validalo al confine con Objects.requireNonNull. Lancia subito l'eccezione, con un messaggio chiaro, nel punto in cui arriva il valore sbagliato invece che in profondità nel codice più tardi:

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        try {
            new Account(null);
        } catch (NullPointerException e) {
            System.out.println("Rejected: " + e.getMessage());
        }
    }

    static class Account {
        final String owner;

        Account(String owner) {
            this.owner = Objects.requireNonNull(owner, "owner must not be null");
        }
    }
}

L'abitudine di "fallire subito" trasforma una NPE vaga a 200 righe di distanza in una segnalazione precisa all'origine. Qui l'eccezione viene catturata solo per mostrare il messaggio: nel codice reale la lasceresti emergere perché il bug venga corretto.

Evitare i null fin dall'inizio

La NPE migliore è quella che non può mai verificarsi perché non c'è nessun null da incontrare. Alcune abitudini aiutano molto:

• Restituisci una collezione o una stringa vuota, mai null. Collections.emptyList() e "" sono sicuri da scorrere in un ciclo e su cui chiamare metodi.
• Usa getOrDefault sulle mappe, così una ricerca a vuoto produce un valore vero invece di null.
• Inizializza i campi quando li dichiari invece di lasciarli null fino a "più tardi".

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);

        // Niente null, nessun rischio di problemi con l'unboxing:
        int boris = ages.getOrDefault("Boris", 0);
        System.out.println("Boris: " + boris);
    }
}

Quando un valore è davvero facoltativo, come una ricerca che può legittimamente non trovare niente, Java offre Optional, un contenitore che obbliga il chiamante a gestire il caso "assente" invece di restituire in silenzio un null. È il concetto correlato da leggere dopo se vuoi eliminare del tutto questi vuoti dalle tue API.

Riepilogo

Una NullPointerException è Java che ti dice che hai usato un riferimento che contiene null come se contenesse un oggetto. La soluzione raramente è catturarla: devi leggere il messaggio dettagliato, risalire al punto in cui il valore avrebbe dovuto essere impostato e poi garantire che non sia null oppure proteggere il punto in cui lo usi. Affidati a Objects.requireNonNull per fallire subito ai confini, preferisci valori vuoti e getOrDefault a null, e usa Optional quando l'assenza è un risultato reale e previsto. Con questa mentalità, l'errore più comune in Java diventa uno dei più rari nel tuo codice.