---
title: "Corrija java.lang.NullPointerException no Kotlin e no Android a partir da mensagem"
description: "java.lang.NullPointerException no Kotlin vem de !!, um valor Java em um tipo não nulo, um cast de null ou um chamador Java. Provocamos 6 casos no JDK 17 e corrigimos cada mensagem."
canonical: "https://logbrew.co/pt-BR/errors/nullpointerexception"
last_updated: "2026-11-10"
---

# Corrija java.lang.NullPointerException no Kotlin e no Android a partir da mensagem

`java.lang.NullPointerException` no Kotlin vem de `!!`, um valor Java em um tipo não nulo, um cast de `null` ou um chamador Java. Provocamos 6 casos no JDK 17 e corrigimos cada mensagem.

Testado em 10 de novembro de 2026 com Kotlin 2.4.0, OpenJDK 17.0.18 e logbrew-kotlin 0.2.3

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday é o fundador do LogBrew. Ele desenvolve o LogBrew com Claude Code e Codex todos os dias.

Canonical: https://logbrew.co/pt-BR/errors/nullpointerexception

## O que cada mensagem de `NullPointerException` indica

| O que o código fez | `NullPointerException` | A mensagem indica a causa |
| --- | --- | --- |
| `order!!` em um valor nulo | Sim | Sem mensagem |
| Um valor Java em uma `val` não nula | Sim | `getProperty(...) must not be null` |
| `null as String` | Sim | `null cannot be cast to non-null type` |
| `null` do Java em um parâmetro Kotlin | Sim | `Parameter specified as non-null is null` |
| Uma chamada de método em `null` no Java | Sim | `Cannot invoke "String.length()"` |
| Uma `lateinit` lida antes de ser definida | `UninitializedPropertyAccessException` | `lateinit property keg has not been initialized` |

6 execuções no JDK 17 com Kotlin 2.4. Uma caneca cheia na primeira coluna significa uma `NullPointerException`, e na segunda que a mensagem indicou a causa.

## Leia a mensagem, depois o primeiro frame

### Encontre a linha no seu próprio código

O primeiro frame do stack trace no seu próprio pacote indica o arquivo e a linha. Quando o stack trace tem uma seção `Caused by:`, leia primeiro os frames abaixo dela. A mensagem então diz qual dos 5 casos abaixo é o seu.

### Sem mensagem, por `!!` em um valor nulo

`!!` lança uma `NullPointerException` sem mensagem, então um logger que imprime a mensagem depois de dois-pontos mostra `java.lang.NullPointerException: null`. A linha do primeiro frame contém o `!!`.

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

Saída

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

### `must not be null` quando um valor Java entrou em um tipo não nulo

Um método Java retorna um tipo de plataforma, e o Kotlin só confere o valor quando você o coloca em uma variável não nula. `getProperty(...)` indica a chamada que retornou `null`.

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

Saída

```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 o Java passou `null` para o Kotlin

O Kotlin confere cada parâmetro não nulo de uma função pública quando ela é chamada, então um `null` vindo do Java falha na primeira linha da função. A mensagem indica a função e o parâmetro.

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

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

Saída

```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` depois de um cast de `null`

`as String` em um `null` lança a exceção. `as? String` retorna `null` em vez disso, e na nossa execução foi o que aconteceu, sem exceção.

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

Saída

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

### `Cannot invoke` por uma chamada de método em `null` em código Java

Desde o JDK 15, o Java indica o método e a variável. `<local0>` significa que a classe foi compilada sem `-g`, então o nome da variável está faltando. Compile com `javac -g` para vê-lo. No Android, o runtime escreve `Attempt to invoke virtual method ... on a null object reference` em vez disso.

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

Saída

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

## Corrija no Kotlin e no Android

### Troque `!!` por um fallback ou uma falha com nome

`?:` dá um valor padrão ou sai da função. `requireNotNull()` com uma mensagem falha na hora e diz o que faltou, então o primeiro frame e a mensagem apontam os dois para a causa.

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

Saída

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

### Declare o tipo como anulável na fronteira com o Java

Dê a um valor vindo do Java um tipo anulável, e o compilador obriga você a tratar o `null` antes de usá-lo. Anote seu próprio Java com `@Nullable` e `@NonNull`, e o Kotlin vê um tipo real em vez de um tipo de plataforma.

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

### Deixe o parser de JSON falhar no parse, não depois

Um parser que constrói objetos por reflexão pode colocar `null` em uma propriedade Kotlin não nula, e a exceção aparece longe do parse. A square/moshi#143 relatou isso em 2016. Foi fechada em janeiro de 2018 com a resposta de usar o adaptador Kotlin, que rejeita um campo não nulo ausente.

### Use `lateinit` só para valores definidos antes do primeiro uso

Uma propriedade `lateinit` lida antes de ser definida lança `UninitializedPropertyAccessException`, não uma `NullPointerException`. Confira `::keg.isInitialized` antes, ou use `by lazy` quando puder calcular o valor.

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

Taproom().keg.length
```

Saída

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

### Envie a exceção com o stack trace para o LogBrew

`captureThrowable()` no SDK Kotlin envia o tipo da exceção, os frames do stack trace e a cadeia de causas, e o LogBrew agrupa as repetições em 1 problema. A mensagem fica de fora a menos que você passe `includeMessage = true`. No seu app, passe `HttpTransport()` para `flush()` em vez do transporte de gravação.

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

Saída

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

## O que vimos no teste

Compilamos 1 arquivo Kotlin e 1 arquivo Java com Kotlin 2.4.0 no OpenJDK 17.0.18 e provocamos a exceção de 6 formas. 4 vieram de código Kotlin, com `!!`, um valor Java em uma `val` não nula, `as String` em `null` e um `null` que o Java passou para um parâmetro Kotlin. A quinta foi uma chamada de método em `null` no Java. A sexta, uma leitura de `lateinit`, nem era uma `NullPointerException`.

Só o caso do `!!` não tinha mensagem. Os outros 4 indicaram a chamada, o parâmetro, o tipo ou o método. A mensagem do Java dizia `<local0>` para a variável porque compilamos sem `-g`.

`requireNotNull()` com uma mensagem lançou `IllegalArgumentException: keg is not set for tap 3` na linha em que o escrevemos. `as? String` retornou `null` sem exceção.

## Por que o Kotlin ainda lança NullPointerException

O compilador Kotlin rejeita uma chamada em um tipo anulável, então o código Kotlin só lança uma `NullPointerException` onde você pede uma. A documentação de null safety lista `!!`, um `throw` explícito, um `this` não inicializado e a interoperabilidade com Java como as únicas causas. Um cast de `null` com `as` também lança uma, como mostra a nossa execução.

Um valor vindo do Java tem um tipo de plataforma, escrito `String!` nas mensagens do compilador. Você pode colocá-lo em uma `String` ou em uma `String?`. Em uma `String`, o Kotlin confere na atribuição e lança `must not be null`, que foi onde a nossa segunda execução falhou.

A JEP 358 adicionou a mensagem `Cannot invoke ... because ... is null` à JVM no JDK 14, e o JDK 15 a ativou por padrão. O runtime do Android escreve o próprio texto. A google/gson#1778 mostra isso em um app Android, como `Attempt to invoke virtual method 'int java.lang.Object.hashCode()' on a null object reference`.

## O que o LogBrew registra

`captureThrowable()` enviou 1 problema com o título `NullPointerException` no nível `error`, com `exception.type` `NullPointerException`, o mecanismo `android.exception` e `handled: true`. A cadeia de causas tinha 1 entrada para `java.lang.NullPointerException` com 7 frames, cada um com arquivo, linha, função e módulo. O primeiro frame era `main` em `Npe.kt` na linha 58.

A mensagem estava ausente, e a entrada da cadeia dizia `messageState: "redacted"`. Com `includeMessage = true`, o problema trazia `getProperty(...) must not be null` como mensagem. Com `includeStackTrace = true`, o campo de metadados `throwableStackTrace` continha o texto do stack trace sem a mensagem.

`flush()` respondeu `statusCode=202, attempts=1` pelo transporte de gravação. O mesmo corpo vai para o LogBrew quando você passa `HttpTransport()`.

## Perguntas frequentes

### O que é uma NullPointerException?

A exceção que a JVM lança quando o código usa uma referência que contém `null` em uma chamada de método, uma leitura de campo, um índice de array ou um unboxing. Ela estende `RuntimeException`, então nenhuma cláusula `throws` a declara.

### Por que o Kotlin lança NullPointerException se tem null safety?

O Kotlin confere a nulidade em tempo de compilação só para tipos Kotlin. `!!`, `as` em `null`, um valor Java que você coloca em um tipo não nulo e um chamador Java que passa `null` lançam todos em tempo de execução. Cada um tem a própria mensagem, listada acima.

### O que significa `java.lang.NullPointerException: null`?

A exceção não tem mensagem. O código que imprime a mensagem depois de dois-pontos escreve `null` ali. No Kotlin, `!!` lança exatamente essa exceção, então procure `!!` na linha do primeiro frame.

### O que significa Parameter specified as non-null is null?

O Java, ou a reflexão, passou `null` para uma função Kotlin cujo parâmetro é não nulo. A mensagem indica a função e o parâmetro. Torne o parâmetro anulável, ou impeça o `null` do lado de quem chama.

### Como corrijo NullPointerException no Android?

Leia o frame abaixo de `Caused by:` que está no seu pacote, depois compare a mensagem com os casos acima. No Android, o runtime escreve `Attempt to invoke virtual method ... on a null object reference`, e o método que ele indica é a chamada no `null`.

### NullPointerException é uma exceção verificada (checked)?

Não. Ela estende `RuntimeException`, então o compilador não obriga você a capturá-la. Corrija a causa em vez de capturá-la, porque um `null` que chega a uma chamada de método é um bug no código anterior.

## Veja cada NullPointerException com o stack trace

O SDK Kotlin do LogBrew envia cada exceção com o tipo, os frames do stack trace e a cadeia de causas, e o LogBrew agrupa as repetições em 1 problema. Comece no plano gratuito generoso, sem cartão.

[Comece grátis](https://logbrew.co/pt-BR)

## Fontes

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

## Mais correções de erros

- [Corrija o erro de script que esconde a mensagem, o arquivo e a linha](https://logbrew.co/pt-BR/errors/script-error)
- [Corrija o erro Failed to fetch e distinga as 3 causas](https://logbrew.co/pt-BR/errors/failed-to-fetch)
- [Erros que reproduzimos, e como corrigir cada um](https://logbrew.co/pt-BR/errors)