---
title: "java.lang.NullPointerException in Kotlin und Android aus der Meldung beheben"
description: "java.lang.NullPointerException in Kotlin kommt von !!, einem Java-Wert als Non-Null-Typ, einem Cast von null oder einem Java-Aufrufer. 6 Fälle auf JDK 17, mit der Lösung für jede Meldung."
canonical: "https://logbrew.co/de/errors/nullpointerexception"
last_updated: "2026-11-10"
---

# java.lang.NullPointerException in Kotlin und Android aus der Meldung beheben

`java.lang.NullPointerException` in Kotlin kommt von `!!`, einem Java-Wert als Non-Null-Typ, einem Cast von `null` oder einem Java-Aufrufer. 6 Fälle auf JDK 17, mit der Lösung für jede Meldung.

Getestet am 10. November 2026 mit Kotlin 2.4.0, OpenJDK 17.0.18 und logbrew-kotlin 0.2.3

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

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

## Was jede `NullPointerException`-Meldung nennt

| Was der Code getan hat | `NullPointerException` | Meldung nennt die Ursache |
| --- | --- | --- |
| `order!!` auf einem null-Wert | Ja | Keine Meldung |
| Ein Java-Wert in ein Non-Null-`val` | Ja | `getProperty(...) must not be null` |
| `null as String` | Ja | `null cannot be cast to non-null type` |
| `null` aus Java in einen Kotlin-Parameter | Ja | `Parameter specified as non-null is null` |
| Ein Methodenaufruf auf `null` in Java | Ja | `Cannot invoke "String.length()"` |
| Ein `lateinit`, gelesen, bevor es gesetzt ist | `UninitializedPropertyAccessException` | `lateinit property keg has not been initialized` |

6 Läufe auf JDK 17 mit Kotlin 2.4. Eine volle Tasse in der ersten Spalte heißt, es gab eine `NullPointerException`, in der zweiten, dass ihre Meldung die Ursache nennt.

## Erst die Meldung lesen, dann den ersten Frame

### Die Zeile im eigenen Code finden

Der erste Stackframe in deinem eigenen Package nennt Datei und Zeile. Hat der Trace einen Abschnitt `Caused by:`, lies zuerst die Frames darunter. Die Meldung sagt dir dann, welchen der 5 Fälle unten du hast.

### Keine Meldung, von `!!` auf einem null-Wert

`!!` wirft eine `NullPointerException` ohne Meldung, ein Logger, der die Meldung nach einem Doppelpunkt ausgibt, zeigt also `java.lang.NullPointerException: null`. Die Zeile im ersten Frame enthält das `!!`.

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

Ausgabe

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

### `must not be null`, wenn ein Java-Wert in einen Non-Null-Typ kam

Eine Java-Methode gibt einen Plattformtyp zurück, und Kotlin prüft ihn erst, wenn du ihn in eine Non-Null-Variable legst. `getProperty(...)` nennt den Aufruf, der `null` zurückgab.

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

Ausgabe

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

### `Parameter specified as non-null is null`, wenn Java `null` an Kotlin übergab

Kotlin prüft jeden Non-Null-Parameter einer öffentlichen Funktion beim Aufruf, ein `null` aus Java scheitert also in der ersten Zeile der Funktion. Die Meldung nennt die Funktion und den Parameter.

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

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

Ausgabe

```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` nach einem Cast von `null`

`as String` auf einem `null` wirft. `as? String` gibt stattdessen `null` zurück, und in unserem Lauf tat es das, ohne Exception.

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

Ausgabe

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

### `Cannot invoke` von einem Methodenaufruf auf `null` in Java-Code

Seit JDK 15 nennt Java die Methode und die Variable. `<local0>` heißt, die Klasse wurde ohne `-g` kompiliert, der Variablenname fehlt also. Kompiliere mit `javac -g`, um ihn zu sehen. Auf Android schreibt die Laufzeit stattdessen `Attempt to invoke virtual method ... on a null object reference`.

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

Ausgabe

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

## In Kotlin und Android beheben

### `!!` durch einen Fallback oder einen benannten Fehler ersetzen

`?:` liefert einen Standardwert oder verlässt die Funktion. `requireNotNull()` mit Meldung scheitert sofort und sagt, was gefehlt hat, erster Frame und Meldung zeigen also beide auf die Ursache.

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

Ausgabe

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

### Den Typ an der Java-Grenze nullable deklarieren

Gib einem Wert aus Java einen nullable Typ, dann zwingt dich der Compiler, `null` zu behandeln, bevor du ihn nutzt. Annotiere dein eigenes Java mit `@Nullable` und `@NonNull`, dann sieht Kotlin einen echten Typ statt eines Plattformtyps.

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

### Einen JSON-Parser beim Parsen scheitern lassen, nicht später

Ein Parser, der Objekte per Reflection baut, kann `null` in eine Non-Null-Property in Kotlin legen, und die Exception taucht weit weg vom Parsen auf. square/moshi#143 meldete das 2016. Es wurde im Januar 2018 geschlossen, mit der Antwort, den Kotlin-Adapter zu nutzen, der ein fehlendes Non-Null-Feld ablehnt.

### `lateinit` nur für Werte nutzen, die vor dem ersten Zugriff gesetzt sind

Eine `lateinit`-Property, die vor dem Setzen gelesen wird, wirft `UninitializedPropertyAccessException`, keine `NullPointerException`. Prüfe zuerst `::keg.isInitialized`, oder nimm `by lazy`, wenn du den Wert berechnen kannst.

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

Taproom().keg.length
```

Ausgabe

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

### Die Exception mit ihrem Stack an LogBrew senden

`captureThrowable()` im Kotlin-SDK sendet den Exception-Typ, seine Stackframes und seine Ursachenkette, und LogBrew gruppiert Wiederholungen in 1 Issue. Die Meldung bleibt draußen, außer du übergibst `includeMessage = true`. In deiner App übergibst du `HttpTransport()` an `flush()` statt des aufzeichnenden Transports.

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

Ausgabe

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

## Was wir beim Testen gesehen haben

Wir haben 1 Kotlin-Datei und 1 Java-Datei mit Kotlin 2.4.0 auf OpenJDK 17.0.18 kompiliert und die Exception auf 6 Arten ausgelöst. Vier kamen aus Kotlin-Code, mit `!!`, einem Java-Wert in einem Non-Null-`val`, `as String` auf `null` und einem `null`, das Java an einen Kotlin-Parameter übergab. Der fünfte war ein Methodenaufruf auf `null` in Java. Der sechste, ein `lateinit`-Zugriff, war gar keine `NullPointerException`.

Nur der Fall mit `!!` hatte keine Meldung. Die anderen 4 nannten den Aufruf, den Parameter, den Typ oder die Methode. Die Java-Meldung sagte `<local0>` für die Variable, weil wir ohne `-g` kompiliert haben.

`requireNotNull()` mit Meldung warf `IllegalArgumentException: keg is not set for tap 3` in der Zeile, in der wir es geschrieben haben. `as? String` gab `null` zurück, ohne Exception.

## Warum Kotlin trotzdem NullPointerException wirft

Der Kotlin-Compiler lehnt einen Aufruf auf einem nullable Typ ab, Kotlin-Code wirft eine `NullPointerException` also nur dort, wo du eine verlangst. Die Doku zur Null-Sicherheit nennt `!!`, ein explizites `throw`, ein nicht initialisiertes `this` und die Java-Interoperabilität als einzige Ursachen. Ein Cast von `null` mit `as` wirft auch eine, wie unser Lauf zeigt.

Ein Wert aus Java hat einen Plattformtyp, in Compiler-Meldungen als `String!` geschrieben. Du kannst ihn in einen `String` oder einen `String?` legen. In einem `String` prüft Kotlin ihn bei der Zuweisung und wirft `must not be null`, und genau da ist unser zweiter Lauf gescheitert.

JEP 358 brachte die Meldung `Cannot invoke ... because ... is null` mit JDK 14 in die JVM, und JDK 15 schaltete sie standardmäßig ein. Die Android-Laufzeit schreibt ihren eigenen Text. google/gson#1778 zeigt ihn aus einer Android-App, als `Attempt to invoke virtual method 'int java.lang.Object.hashCode()' on a null object reference`.

## Was LogBrew aufzeichnet

`captureThrowable()` schickte 1 Issue mit dem Titel `NullPointerException` auf Level `error`, mit `exception.type` `NullPointerException`, dem Mechanismus `android.exception` und `handled: true`. Die Ursachenkette hielt 1 Eintrag für `java.lang.NullPointerException` mit 7 Stackframes, jeder mit Datei, Zeile, Funktion und Modul. Der erste Frame war `main` in `Npe.kt` in Zeile 58.

Die Meldung fehlte, und der Ketteneintrag sagte `messageState: "redacted"`. Mit `includeMessage = true` trug das Issue `getProperty(...) must not be null` als Meldung. Mit `includeStackTrace = true` hielt das Metadatenfeld `throwableStackTrace` den Trace-Text ohne die Meldung.

`flush()` antwortete über den aufzeichnenden Transport mit `statusCode=202, attempts=1`. Derselbe Body geht an LogBrew, wenn du `HttpTransport()` übergibst.

## Häufige Fragen

### Was ist eine NullPointerException?

Die Exception, die die JVM wirft, wenn Code eine Referenz mit `null` in einem Methodenaufruf, einem Feldzugriff, einem Array-Index oder einem Unboxing nutzt. Die Klasse erbt von `RuntimeException`, keine `throws`-Klausel nennt sie also.

### Warum wirft Kotlin eine NullPointerException, obwohl es Null-Sicherheit hat?

Kotlin prüft Nullability zur Compile-Zeit nur für Kotlin-Typen. `!!`, `as` auf `null`, ein Java-Wert, den du in einen Non-Null-Typ legst, und ein Java-Aufrufer, der `null` übergibt, werfen alle zur Laufzeit. Jeder hat seine eigene Meldung, oben aufgelistet.

### Was bedeutet `java.lang.NullPointerException: null`?

Die Exception hat keine Meldung. Code, der die Meldung nach einem Doppelpunkt ausgibt, schreibt dort `null`. In Kotlin wirft `!!` genau diese Exception, such also nach `!!` in der Zeile des ersten Frames.

### Was bedeutet Parameter specified as non-null is null?

Java oder Reflection hat `null` an eine Kotlin-Funktion übergeben, deren Parameter non-null ist. Die Meldung nennt die Funktion und den Parameter. Mach den Parameter nullable, oder stoppe das `null` auf der Seite des Aufrufers.

### Wie behebe ich eine NullPointerException in Android?

Lies den Frame unter `Caused by:`, der in deinem Package liegt, und ordne die Meldung dann den Fällen oben zu. Auf Android schreibt die Laufzeit `Attempt to invoke virtual method ... on a null object reference`, und die Methode, die sie nennt, ist der Aufruf auf dem `null`.

### Ist NullPointerException eine Checked Exception?

Nein. Die Klasse erbt von `RuntimeException`, der Compiler zwingt dich also nicht, sie zu fangen. Behebe die Ursache, statt sie zu fangen, denn ein `null`, das einen Methodenaufruf erreicht, ist ein Bug im Code davor.

## Jede NullPointerException mit ihrem Stack sehen

Das LogBrew-Kotlin-SDK sendet jede Exception mit Typ, Stackframes und Ursachenkette, und LogBrew gruppiert Wiederholungen in 1 Issue. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

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

## Weitere Fehler beheben

- [Den Script error beheben, der Meldung, Datei und Zeile verbirgt](https://logbrew.co/de/errors/script-error)
- [Den Fehler Failed to fetch beheben und seine 3 Ursachen unterscheiden](https://logbrew.co/de/errors/failed-to-fetch)
- [Fehler, die wir reproduziert haben, und wie du jeden behebst](https://logbrew.co/de/errors)