---
title: "Risolvi java.lang.NullPointerException in Kotlin e Android partendo dal messaggio"
description: "java.lang.NullPointerException in Kotlin viene da !!, un valore Java in un tipo non nullable, un cast di null o un chiamante Java. 6 casi su JDK 17, con la soluzione per ogni messaggio."
canonical: "https://logbrew.co/it/errors/nullpointerexception"
last_updated: "2026-11-10"
---

# Risolvi java.lang.NullPointerException in Kotlin e Android partendo dal messaggio

`java.lang.NullPointerException` in Kotlin viene da `!!`, un valore Java in un tipo non nullable, un cast di `null` o un chiamante Java. 6 casi su JDK 17, con la soluzione per ogni messaggio.

Testato il 10 novembre 2026 con Kotlin 2.4.0, OpenJDK 17.0.18 e logbrew-kotlin 0.2.3

Di [Furkan Erday](https://github.com/furkanerday). Furkan Erday è il fondatore di LogBrew. Sviluppa LogBrew ogni giorno con Claude Code e Codex.

Canonical: https://logbrew.co/it/errors/nullpointerexception

## Cosa indica ogni messaggio di `NullPointerException`

| Cosa ha fatto il codice | `NullPointerException` | Il messaggio indica la causa |
| --- | --- | --- |
| `order!!` su un valore null | Sì | Nessun messaggio |
| Un valore Java in una `val` non nullable | Sì | `getProperty(...) must not be null` |
| `null as String` | Sì | `null cannot be cast to non-null type` |
| `null` da Java in un parametro Kotlin | Sì | `Parameter specified as non-null is null` |
| Una chiamata di metodo su `null` in Java | Sì | `Cannot invoke "String.length()"` |
| Una `lateinit` letta prima di essere impostata | `UninitializedPropertyAccessException` | `lateinit property keg has not been initialized` |

6 esecuzioni su JDK 17 con Kotlin 2.4. Una tazza piena nella prima colonna significa una `NullPointerException`, nella seconda che il messaggio ha indicato la causa.

## Leggi il messaggio, poi il primo frame

### Trova la riga nel tuo codice

Il primo frame dello stack nel tuo package indica il file e la riga. Quando lo stack trace ha una sezione `Caused by:`, leggi prima i frame sotto di essa. Il messaggio ti dice poi quale dei 5 casi qui sotto hai davanti.

### Nessun messaggio, da `!!` su un valore null

`!!` lancia una `NullPointerException` senza messaggio, quindi un logger che stampa il messaggio dopo i due punti mostra `java.lang.NullPointerException: null`. La riga nel primo frame contiene il `!!`.

```bash
val order: String? = null
order!!.length
```

Output

```text
java.lang.NullPointerException
	at NpeKt.main$lambda$0(Npe.kt:27)
```

### `must not be null` quando un valore Java è finito in un tipo non nullable

Un metodo Java restituisce un platform type, e Kotlin lo controlla solo quando lo metti in una variabile non nullable. `getProperty(...)` indica la chiamata che ha restituito `null`.

```bash
val beer: String = System.getProperty("taproom.beer")
```

Output

```text
java.lang.NullPointerException: getProperty(...) must not be null
	at NpeKt.main$lambda$1(Npe.kt:30)
```

### `Parameter specified as non-null is null` quando Java ha passato `null` a Kotlin

Kotlin controlla ogni parametro non nullable di una funzione pubblica quando la funzione viene chiamata, quindi un `null` da Java fallisce sulla prima riga della funzione. Il messaggio indica la funzione e il parametro.

```bash
// Kotlin
fun greet(name: String): Int = name.length

// Java
NpeKt.greet(null);
```

Output

```text
java.lang.NullPointerException: Parameter specified as non-null is null: method NpeKt.greet, parameter name
	at NpeKt.greet(Npe.kt)
```

### `null cannot be cast to non-null type` dopo un cast di `null`

`as String` su un `null` lancia l’eccezione. `as? String` restituisce `null` al suo posto, e nel nostro test è andata così, senza eccezione.

```bash
val value: Any? = null
value as String
```

Output

```text
java.lang.NullPointerException: null cannot be cast to non-null type kotlin.String
	at NpeKt.main$lambda$2(Npe.kt:35)
```

### `Cannot invoke` da una chiamata di metodo su `null` in codice Java

Da JDK 15, Java indica il metodo e la variabile. `<local0>` significa che la classe è stata compilata senza `-g`, quindi manca il nome della variabile. Compila con `javac -g` per vederlo. Su Android, il runtime scrive invece `Attempt to invoke virtual method ... on a null object reference`.

```bash
String beer = null;
beer.length();
```

Output

```text
java.lang.NullPointerException: Cannot invoke "String.length()" because "<local0>" is null
	at Caller.lengthOfNull(Caller.java:10)
```

## Risolvilo in Kotlin e Android

### Sostituisci `!!` con un fallback o un errore con nome

`?:` dà un valore di default o esce dalla funzione. `requireNotNull()` con un messaggio fallisce subito e dice cosa mancava, così il primo frame e il messaggio puntano entrambi alla causa.

```bash
val order = orders[id] ?: return
val keg = requireNotNull(taps[id]) { "keg is not set for tap $id" }
```

Output

```text
java.lang.IllegalArgumentException: keg is not set for tap 3
	at NpeKt.main$lambda$6(Npe.kt:48)
```

### Dichiara il tipo nullable al confine con Java

Dai a un valore che arriva da Java un tipo nullable, e il compilatore ti obbliga a gestire il `null` prima di usarlo. Annota il tuo codice Java con `@Nullable` e `@NonNull`, e Kotlin vede un tipo reale invece di un platform type.

```bash
val beer: String? = System.getProperty("taproom.beer")
val name = beer ?: "house ale"
```

### Lascia che il parser JSON fallisca al parsing, non dopo

Un parser che costruisce gli oggetti per reflection può mettere `null` in una proprietà Kotlin non nullable, e l’eccezione compare lontano dal parsing. square/moshi#143 lo ha segnalato nel 2016. È stata chiusa a gennaio 2018 con la risposta di usare l’adapter Kotlin, che rifiuta un campo non nullable mancante.

### Usa `lateinit` solo per valori impostati prima del primo uso

Una proprietà `lateinit` letta prima di essere impostata lancia `UninitializedPropertyAccessException`, non una `NullPointerException`. Controlla prima `::keg.isInitialized`, o usa `by lazy` quando puoi calcolare il valore.

```bash
class Taproom {
    lateinit var keg: String
}

Taproom().keg.length
```

Output

```text
kotlin.UninitializedPropertyAccessException: lateinit property keg has not been initialized
	at Taproom.getKeg(Npe.kt:6)
```

### Invia l’eccezione con il suo stack a LogBrew

`captureThrowable()` nell’SDK Kotlin invia il tipo dell’eccezione, i frame dello stack e la catena delle cause, e LogBrew raggruppa le ripetizioni in 1 problema. Il messaggio resta fuori a meno che tu non passi `includeMessage = true`. Nella tua app, passa `HttpTransport()` a `flush()` invece del transport di registrazione.

```bash
import co.logbrew.sdk.LogBrewAndroid
import co.logbrew.sdk.LogBrewClient
import co.logbrew.sdk.RecordingTransport

val transport = RecordingTransport.alwaysAccept()
val client = LogBrewClient.create(apiKey = System.getenv("LOGBREW_API_KEY"), sdkName = "logbrew-kotlin", sdkVersion = "0.2.3")
try {
    val beer: String = System.getProperty("taproom.beer")
    beer.length
} catch (e: NullPointerException) {
    LogBrewAndroid.captureThrowable(client, "evt_npe_1", "2026-11-10T09:00:00Z", e)
}
println(client.flush(transport))
```

Output

```text
TransportResponse(statusCode=202, attempts=1)
```

## Cosa abbiamo visto nei test

Abbiamo compilato 1 file Kotlin e 1 file Java con Kotlin 2.4.0 su OpenJDK 17.0.18 e provocato l’eccezione in 6 modi. 4 venivano da codice Kotlin, con `!!`, un valore Java in una `val` non nullable, `as String` su `null` e un `null` che Java ha passato a un parametro Kotlin. Il quinto era una chiamata di metodo su `null` in Java. Il sesto, una lettura di `lateinit`, non era affatto una `NullPointerException`.

Solo il caso con `!!` non aveva messaggio. Gli altri 4 indicavano la chiamata, il parametro, il tipo o il metodo. Il messaggio Java diceva `<local0>` per la variabile perché abbiamo compilato senza `-g`.

`requireNotNull()` con un messaggio ha lanciato `IllegalArgumentException: keg is not set for tap 3` sulla riga in cui l’abbiamo scritto. `as? String` ha restituito `null` senza eccezione.

## Perché Kotlin lancia ancora NullPointerException

Il compilatore Kotlin rifiuta una chiamata su un tipo nullable, quindi il codice Kotlin lancia una `NullPointerException` solo dove la chiedi tu. La documentazione sulla null safety elenca `!!`, un `throw` esplicito, un `this` non inizializzato e l’interoperabilità con Java come uniche cause. Anche un cast di `null` con `as` ne lancia una, come mostra il nostro test.

Un valore che arriva da Java ha un platform type, scritto `String!` nei messaggi del compilatore. Puoi metterlo in una `String` o in una `String?`. In una `String`, Kotlin lo controlla all’assegnazione e lancia `must not be null`, ed è lì che il nostro secondo test è fallito.

La JEP 358 ha aggiunto il messaggio `Cannot invoke ... because ... is null` alla JVM in JDK 14, e JDK 15 lo ha attivato di default. Il runtime di Android scrive un testo suo. google/gson#1778 lo mostra da un’app Android, come `Attempt to invoke virtual method 'int java.lang.Object.hashCode()' on a null object reference`.

## Cosa registra LogBrew

`captureThrowable()` ha inviato 1 problema con titolo `NullPointerException` a livello `error`, con `exception.type` `NullPointerException`, il meccanismo `android.exception` e `handled: true`. La catena delle cause aveva 1 voce per `java.lang.NullPointerException` con 7 frame dello stack, ognuno con file, riga, funzione e modulo. Il primo frame era `main` in `Npe.kt` alla riga 58.

Il messaggio era assente, e la voce della catena diceva `messageState: "redacted"`. Con `includeMessage = true`, il problema portava `getProperty(...) must not be null` come messaggio. Con `includeStackTrace = true`, il campo di metadati `throwableStackTrace` conteneva il testo dello stack senza il messaggio.

`flush()` ha risposto `statusCode=202, attempts=1` attraverso il transport di registrazione. Lo stesso body va a LogBrew quando passi `HttpTransport()`.

## Domande frequenti

### Cos’è una NullPointerException?

L’eccezione che la JVM lancia quando il codice usa un riferimento che contiene `null` in una chiamata di metodo, una lettura di campo, un indice di array o un unboxing. Estende `RuntimeException`, quindi nessuna clausola `throws` la dichiara.

### Perché Kotlin lancia NullPointerException se ha la null safety?

Kotlin controlla la nullabilità a compile time solo per i tipi Kotlin. `!!`, `as` su `null`, un valore Java che metti in un tipo non nullable e un chiamante Java che passa `null` lanciano tutti a runtime. Ognuno ha il suo messaggio, elencato sopra.

### Cosa significa `java.lang.NullPointerException: null`?

L’eccezione non ha messaggio. Il codice che stampa il messaggio dopo i due punti scrive `null` in quel punto. In Kotlin, `!!` lancia esattamente questa eccezione, quindi cerca `!!` sulla riga del primo frame.

### Cosa significa Parameter specified as non-null is null?

Java, o la reflection, ha passato `null` a una funzione Kotlin il cui parametro è non nullable. Il messaggio indica la funzione e il parametro. Rendi il parametro nullable, o ferma il `null` dal lato del chiamante.

### Come risolvo NullPointerException su Android?

Leggi il frame sotto `Caused by:` che sta nel tuo package, poi confronta il messaggio con i casi sopra. Su Android il runtime scrive `Attempt to invoke virtual method ... on a null object reference`, e il metodo che indica è la chiamata sul `null`.

### NullPointerException è un’eccezione checked?

No. Estende `RuntimeException`, quindi il compilatore non ti obbliga a catturarla. Risolvi la causa invece di catturarla, perché un `null` che arriva a una chiamata di metodo è un bug nel codice che viene prima.

## Vedi ogni NullPointerException con il suo stack

L’SDK Kotlin di LogBrew invia ogni eccezione con tipo, frame dello stack e catena delle cause, e LogBrew raggruppa le ripetizioni in 1 problema. Inizia con il generoso piano gratuito, senza carta.

[Inizia gratis](https://logbrew.co/it)

## Fonti

- [Kotlin docs, Null safety](https://kotlinlang.org/docs/null-safety.html)
- [Kotlin docs, Null-safety and platform types](https://kotlinlang.org/docs/java-interop.html#null-safety-and-platform-types)
- [JEP 358, Helpful NullPointerExceptions](https://openjdk.org/jeps/358)
- [square/moshi#143](https://github.com/square/moshi/issues/143)
- [google/gson#1778](https://github.com/google/gson/issues/1778)

## Altre soluzioni agli errori

- [Risolvi l’errore di script che nasconde messaggio, file e riga](https://logbrew.co/it/errors/script-error)
- [Risolvi l’errore Failed to fetch e distingui le sue 3 cause](https://logbrew.co/it/errors/failed-to-fetch)
- [Errori che abbiamo riprodotto, e come risolvere ciascuno](https://logbrew.co/it/errors)