Uma NullPointerException em Java é uma RuntimeException. Ocorre quando um programa tenta usar uma referência de objeto que possui o valor nulo. Em Java, 'nulo' é um valor especial que pode ser atribuído a referências de objetos para indicar a ausência de um valor.

Razões para exceção de ponteiro nulo

Uma NullPointerException ocorre pelos seguintes motivos: 

• Invocando um método a partir de um objeto nulo.
• Acessando ou modificando o campo de um objeto nulo.
• Tomando o comprimento de null como se fosse um array.
• Acessando ou modificando os slots de objetos nulos como se fosse um array.
• Jogando null como se fosse um valor Throwable.
• Quando você tenta sincronizar em um objeto nulo.

Exemplo:

função anônima java

public class Geeks {    public static void main(String[] args) {    // Reference set to null  String s = null;     System.out.println(s.length());   } } 

Saída:

Hangup (SIGHUP)  
Exception in thread 'main' java.lang.NullPointerException  
 at Geeks.main(Geeks.java:10)

Explicação: Neste exemplo, a referência da string 's' é nula. Quando o programa tenta chamar o método length() ele lança uma NullPointerException porque não há nenhum objeto real.

Por que null é usado em Java?

O valor nulo serve como espaço reservado e indica que nenhum valor foi atribuído a uma variável de referência. As aplicações comuns incluem:

• Estruturas de dados vinculadas : representa o final de uma lista ou galho de árvore.
• Padrões de projeto : Isso é usado em padrões como Null Object Pattern ou Singleton Pattern.

Como evitar NullPointerException

Para evitar o NullPointerException devemos garantir que todos os objetos sejam inicializados corretamente antes de usá-los. Quando declaramos uma variável de referência, devemos verificar se o objeto não é nulo antes de solicitarmos um método ou campo dos objetos.

arquitetura de colmeia

1. Usando literais de string em equals()

Um problema de caso muito comum envolve a comparação entre uma variável String e um literal. O literal pode ser uma String ou um elemento de um Enum. Em vez de invocar o método a partir do objeto nulo, considere invocá-lo a partir do literal. 

Exemplo:

quem inventou a escola

import java.io.*; class Geeks {  public static void main (String[] args) {    // Initializing String variable with null value  String s = null;  // Checking if s.equals null  try  {  // This line of code throws NullPointerException because s is null  if (s.equals('gfg'))  System.out.print('Same');  else   System.out.print('Not Same');  }  catch(NullPointerException e)  {  System.out.print('NullPointerException Caught');  }  } } 

NullPointerException Caught

Podemos evitar NullPointerException chamando equals em literal em vez de objeto.

import java.io.*; class Geeks {  public static void main (String[] args) {    // Initializing String variable with null value  String s = null;  // Checking if s is null using try catch  try  {  if ('gfg'.equals(s))  System.out.print('Same');  else   System.out.print('Not Same');   }  catch(NullPointerException e)  {  System.out.print('Caught NullPointerException');  }  } } 

Not Same

Observação : sempre invoque iguais no literal para evitar chamar um método em uma referência nula.

2. Verificando argumentos do método

Antes de executar o corpo do novo método, devemos primeiro verificar seus argumentos em busca de valores nulos e continuar com a execução do método somente quando os argumentos forem verificados corretamente. Caso contrário, lançará uma IllegalArgumentException e notificará o método de chamada de que algo está errado com os argumentos passados. 

Exemplo:

import java.io.*; class Geeks {  public static void main(String[] args) {    // String s set an empty string and calling getLength()  String s = '';    try {  System.out.println(getLength(s));  }  catch (IllegalArgumentException e) {  System.out.println(  'IllegalArgumentException caught');  }  // String s set to a value and calling getLength()  s = 'GeeksforGeeks';    try {  System.out.println(getLength(s));  }  catch (IllegalArgumentException e) {  System.out.println(  'IllegalArgumentException caught');  }  // Setting s as null and calling getLength()  s = null;    try {  System.out.println(getLength(s));  }  catch (IllegalArgumentException e) {  System.out.println(  'IllegalArgumentException caught');  }  }  public static int getLength(String s)  {  if (s == null)  throw new IllegalArgumentException(  'The argument cannot be null');    return s.length();  } } 

0 13 IllegalArgumentException caught 

3. Use o operador ternário

O operador ternário pode ser usado para evitar NullPointerException. Primeiro, a expressão booleana é avaliada. Se a expressão for verdadeira, o valor1 será retornado, caso contrário, o valor2 será retornado. Podemos usar o operador ternário para lidar com ponteiros nulos.

Exemplo:

import java.io.*; class Geeks {  public static void main(String[] args)  {  String s = null;  String m = (s == null) ? '' : s.substring(0 5);  System.out.println(m);  s = 'Geeksforgeeks';  m = (s == null) ? '' : s.substring(0 5);  System.out.println(m);  } } 

Geeks 

Explicação : o operador ternário ajuda a verificar nulos e evitar operações em referências nulas.

operadores java

4. Usando classe opcional (Java 8+)

Em Java 8, a classe Opcional foi introduzida como um objeto contêiner que pode ou não conter um valor não nulo. Ajuda a evitar NullPointerException forçando o tratamento explícito do caso quando um valor está ausente.

Exemplo:

import java.util.Optional; public class OptionalExample {  public static void main(String[] args) {  Optional<String> name = Optional.ofNullable(null);  // Safe way to access  System.out.println(name.orElse('Default Name')); // prints: Default Name  } } 

Default Name 

Explicação: Opcional.ofNullable(value) envolve o valor que pode ser nulo. orElse() fornece um substituto se o valor não estiver presente.