---
title: "Corriger java.lang.NullPointerException en Kotlin et Android d’après son message"
description: "En Kotlin, java.lang.NullPointerException vient de !!, d’une valeur Java dans un type non nullable, d’un cast de null ou d’un appel Java. 6 cas sur JDK 17, et le correctif de chacun."
canonical: "https://logbrew.co/fr/errors/nullpointerexception"
last_updated: "2026-11-10"
---

# Corriger java.lang.NullPointerException en Kotlin et Android d’après son message

En Kotlin, `java.lang.NullPointerException` vient de `!!`, d’une valeur Java dans un type non nullable, d’un cast de `null` ou d’un appel Java. 6 cas sur JDK 17, et le correctif de chacun.

Testé le 10 novembre 2026 avec Kotlin 2.4.0, OpenJDK 17.0.18 et logbrew-kotlin 0.2.3

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

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

## Ce que nomme chaque message de `NullPointerException`

| Ce que le code a fait | `NullPointerException` | Le message nomme la cause |
| --- | --- | --- |
| `order!!` sur une valeur null | Oui | Aucun message |
| Une valeur Java dans une `val` non nullable | Oui | `getProperty(...) must not be null` |
| `null as String` | Oui | `null cannot be cast to non-null type` |
| `null` venu de Java dans un paramètre Kotlin | Oui | `Parameter specified as non-null is null` |
| Un appel de méthode sur `null` en Java | Oui | `Cannot invoke "String.length()"` |
| Une lecture de `lateinit` avant son initialisation | `UninitializedPropertyAccessException` | `lateinit property keg has not been initialized` |

6 tests sur JDK 17 avec Kotlin 2.4. Une chope pleine dans la première colonne signifie une `NullPointerException`, et dans la seconde que son message a nommé la cause.

## Lisez le message, puis le premier frame

### Trouvez la ligne dans votre propre code

Le premier frame de la stack trace dans votre propre package nomme le fichier et la ligne. Quand la trace contient une section `Caused by:`, lisez d’abord les frames en dessous. Le message vous dit ensuite lequel des 5 cas ci-dessous vous avez.

### Aucun message, à cause de `!!` sur une valeur null

`!!` lève une `NullPointerException` sans message, donc un logger qui affiche le message après un deux-points montre `java.lang.NullPointerException: null`. La ligne du premier frame contient le `!!`.

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

Sortie

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

### `must not be null` quand une valeur Java est entrée dans un type non nullable

Une méthode Java renvoie un type plateforme, et Kotlin ne le vérifie que quand vous le mettez dans une variable non nullable. `getProperty(...)` nomme l’appel qui a renvoyé `null`.

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

Sortie

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

### `Parameter specified as non-null is null` quand Java a passé `null` à Kotlin

Kotlin vérifie chaque paramètre non nullable d’une fonction publique au moment de l’appel, donc un `null` venu de Java échoue dès la première ligne de la fonction. Le message nomme la fonction et le paramètre.

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

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

Sortie

```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` après un cast de `null`

`as String` sur un `null` lève l’exception. `as? String` renvoie `null` à la place, et c’est ce qui s’est passé dans notre test, sans exception.

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

Sortie

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

### `Cannot invoke` après un appel de méthode sur `null` en Java

Depuis JDK 15, Java nomme la méthode et la variable. `<local0>` signifie que la classe a été compilée sans `-g`, donc le nom de la variable manque. Compilez avec `javac -g` pour le voir. Sur Android, le runtime écrit `Attempt to invoke virtual method ... on a null object reference` à la place.

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

Sortie

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

## Corrigez-la en Kotlin et sur Android

### Remplacez `!!` par une valeur de repli ou un échec nommé

`?:` donne une valeur par défaut ou quitte la fonction. `requireNotNull()` avec un message échoue tout de suite et dit ce qui manquait, donc le premier frame et le message pointent tous les deux vers la cause.

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

Sortie

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

### Déclarez le type nullable à la frontière avec Java

Donnez un type nullable à une valeur venue de Java, et le compilateur vous oblige à gérer `null` avant de l’utiliser. Annotez votre propre code Java avec `@Nullable` et `@NonNull`, et Kotlin voit un vrai type au lieu d’un type plateforme.

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

### Laissez le parseur JSON échouer au parsing, pas plus tard

Un parseur qui construit les objets par réflexion peut mettre `null` dans une propriété Kotlin non nullable, et l’exception apparaît loin du parsing. square/moshi#143 a signalé ce cas en 2016. Il a été fermé en janvier 2018 avec la réponse d’utiliser l’adaptateur Kotlin, qui rejette un champ non nullable manquant.

### Utilisez `lateinit` seulement pour les valeurs définies avant la première lecture

Une propriété `lateinit` lue avant d’être définie lève `UninitializedPropertyAccessException`, pas une `NullPointerException`. Vérifiez d’abord `::keg.isInitialized`, ou utilisez `by lazy` quand vous pouvez calculer la valeur.

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

Taproom().keg.length
```

Sortie

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

### Envoyez l’exception avec sa stack trace à LogBrew

`captureThrowable()` dans le SDK Kotlin envoie le type de l’exception, ses frames de stack trace et sa chaîne de causes, et LogBrew regroupe les répétitions dans 1 problème. Le message reste exclu sauf si vous passez `includeMessage = true`. Dans votre app, passez `HttpTransport()` à `flush()` au lieu du transport d’enregistrement.

```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))
```

Sortie

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

## Ce que nous avons vu en testant

Nous avons compilé 1 fichier Kotlin et 1 fichier Java avec Kotlin 2.4.0 sur OpenJDK 17.0.18 et déclenché l’exception de 6 façons. Quatre venaient du code Kotlin, avec `!!`, une valeur Java dans une `val` non nullable, `as String` sur `null`, et un `null` que Java a passé à un paramètre Kotlin. La cinquième était un appel de méthode sur `null` en Java. La sixième, une lecture de `lateinit`, n’était pas du tout une `NullPointerException`.

Seul le cas `!!` n’avait pas de message. Les 4 autres nommaient l’appel, le paramètre, le type ou la méthode. Le message Java disait `<local0>` pour la variable parce que nous avions compilé sans `-g`.

`requireNotNull()` avec un message a levé `IllegalArgumentException: keg is not set for tap 3` sur la ligne où nous l’avions écrit. `as? String` a renvoyé `null` sans exception.

## Pourquoi Kotlin lève encore NullPointerException

Le compilateur Kotlin refuse un appel sur un type nullable, donc le code Kotlin ne lève une `NullPointerException` que là où vous en demandez une. La documentation sur la null safety cite `!!`, un `throw` explicite, un `this` non initialisé et l’interopérabilité Java comme seules causes. Un cast de `null` avec `as` en lève une aussi, comme le montre notre test.

Une valeur venue de Java a un type plateforme, écrit `String!` dans les messages du compilateur. Vous pouvez la mettre dans une `String` ou une `String?`. Dans une `String`, Kotlin la vérifie à l’affectation et lève `must not be null`, et c’est là que notre deuxième test a échoué.

La JEP 358 a ajouté le message `Cannot invoke ... because ... is null` à la JVM dans JDK 14, et JDK 15 l’a activé par défaut. Le runtime d’Android écrit son propre texte. google/gson#1778 le montre depuis une app Android, sous la forme `Attempt to invoke virtual method 'int java.lang.Object.hashCode()' on a null object reference`.

## Ce que LogBrew enregistre

`captureThrowable()` a envoyé 1 problème intitulé `NullPointerException` au niveau `error`, avec `exception.type` `NullPointerException`, le mécanisme `android.exception` et `handled: true`. La chaîne de causes contenait 1 entrée pour `java.lang.NullPointerException` avec 7 frames de stack trace, chacun avec son fichier, sa ligne, sa fonction et son module. Le premier frame était `main` dans `Npe.kt` à la ligne 58.

Le message était absent, et l’entrée de la chaîne disait `messageState: "redacted"`. Avec `includeMessage = true`, le problème portait `getProperty(...) must not be null` comme message. Avec `includeStackTrace = true`, le champ de métadonnées `throwableStackTrace` contenait le texte de la trace sans le message.

`flush()` a répondu `statusCode=202, attempts=1` via le transport d’enregistrement. Le même corps part vers LogBrew quand vous passez `HttpTransport()`.

## Questions fréquentes

### Qu’est-ce qu’une NullPointerException ?

L’exception que la JVM lève quand le code utilise une référence qui contient `null` dans un appel de méthode, une lecture de champ, un index de tableau ou un unboxing. Elle étend `RuntimeException`, donc aucune clause `throws` ne la nomme.

### Pourquoi Kotlin lève-t-il NullPointerException alors qu’il a la null safety ?

Kotlin vérifie la nullabilité à la compilation pour les types Kotlin seulement. `!!`, `as` sur `null`, une valeur Java mise dans un type non nullable et un appelant Java qui passe `null` lèvent tous l’exception à l’exécution. Chacun a son propre message, listé plus haut.

### Que signifie `java.lang.NullPointerException: null` ?

L’exception n’a pas de message. Le code qui affiche le message après un deux-points écrit `null` à cet endroit. En Kotlin, `!!` lève exactement cette exception, donc cherchez `!!` sur la ligne du premier frame.

### Que signifie Parameter specified as non-null is null ?

Java, ou la réflexion, a passé `null` à une fonction Kotlin dont le paramètre est non nullable. Le message nomme la fonction et le paramètre. Rendez le paramètre nullable, ou arrêtez le `null` du côté de l’appelant.

### Comment corriger NullPointerException sur Android ?

Lisez le frame sous `Caused by:` qui est dans votre package, puis faites correspondre le message aux cas ci-dessus. Sur Android, le runtime écrit `Attempt to invoke virtual method ... on a null object reference`, et la méthode qu’il nomme est l’appel sur le `null`.

### NullPointerException est-elle une exception vérifiée ?

Non. Elle étend `RuntimeException`, donc le compilateur ne vous oblige pas à l’attraper. Corrigez la cause au lieu de l’attraper, parce qu’un `null` qui atteint un appel de méthode est un bug dans le code qui précède.

## Voyez chaque NullPointerException avec sa stack trace

Le SDK Kotlin de LogBrew envoie chaque exception avec son type, ses frames de stack trace et sa chaîne de causes, et LogBrew regroupe les répétitions dans 1 problème. Commencez avec le généreux forfait Free, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

- [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)

## D’autres correctifs d’erreurs

- [Corriger l’erreur de script qui cache son message, son fichier et sa ligne](https://logbrew.co/fr/errors/script-error)
- [Corriger l’erreur Failed to fetch et distinguer ses 3 causes](https://logbrew.co/fr/errors/failed-to-fetch)
- [Les erreurs que nous avons reproduites, et comment corriger chacune](https://logbrew.co/fr/errors)