Menu

O que é NullPointerException em Java e como evitá-lo

what is nullpointerexception java how avoid it

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explicará tudo sobre o NullPointerException em Java. Discutiremos as causas da exceção de ponteiro nulo e as maneiras de evitá-la:

NullPointerException em Java é uma exceção de tempo de execução. Java atribui um valor nulo especial a uma referência de objeto. Quando um programa tenta usar uma referência de objeto definida para o valor nulo, essa exceção é lançada.

=> Veja a série de treinamento simples em Java aqui.

NullPointerException em Java

O que você aprenderá:

NullPointerException em Java

Se uma referência de objeto com valor nulo lança NullPointerException, então por que precisamos de um valor nulo?

O valor nulo é geralmente usado para indicar que nenhum valor foi atribuído a uma variável de referência. Em segundo lugar, precisamos de valores nulos para coleções como listas vinculadas e árvores para indicar nós nulos. Os padrões de projeto, como os padrões singleton, usam valores nulos.

Para concluir, o valor nulo em Java tem muitos usos. A exceção de ponteiro nulo é lançada em cenários específicos em Java.

Alguns dos cenários são os seguintes:

  1. Método invocado usando um objeto nulo.
  2. Acessar ou modificar um campo ou membro de dados do objeto nulo.
  3. Passando objeto nulo como argumento para um método.
  4. Calculando o comprimento de uma matriz nula.
  5. Acessando o índice de uma matriz nula.
  6. Sincronizando um objeto nulo.
  7. Jogando um objeto nulo.

A exceção de ponteiro nulo estende-se da classe RuntimeException.

A hierarquia de NullPointerException é fornecida abaixo.

Hierarquia de NullPointerException em Java

Conforme mostrado na hierarquia acima, Null Pointer Exception estende-se da RuntimeException que herda a Exception Class. A classe de exceção, por sua vez, é derivada da classe Throwable, que é uma subclasse de Object.

Causas da ocorrência de java.lang.NullPointerException

Agora vamos demonstrar cada um dos cenários de ocorrência de NullPointerException que listamos acima.

# 1) O método é invocado usando um objeto nulo

Considere o seguinte exemplo de código. Aqui temos uma classe, MyClass, que fornece dois métodos. O primeiro método ‘initT’ retorna um objeto nulo. No método principal, criamos um objeto de MyClass com uma chamada ao método initT.

Em seguida, chamamos o método de impressão de MyClass. Aqui, o java.lang.NullPointerException é lançado quando estamos chamando o método de impressão usando um objeto nulo.

class MyClass { public static MyClass initT() { //method returns a null object return null; } public void print(String s) { System.out.println(s.toLowerCase()); } } class Main{ public static void main(String() args) { MyClass t = MyClass.initT(); //create a new object (null object) t.print('Hello, World!'); //invoke method using null object } }

Resultado

invocado usando um objeto nulo

# 2) Campo de acesso de um objeto nulo

class MyClass { int numField = 100; public static MyClass initT() { //method returns a null object return null; } public void print(String s) { System.out.println(s.toLowerCase()); } } class Main{ public static void main(String() args) { MyClass t = MyClass.initT(); //create a new object (null object) int num = t.numField; //access MyClass member using null object } }

Resultado

Campo de acesso de um objeto nulo

c ++ inicializar variável estática

Esta é outra causa de NullPointerException. Aqui, tentamos acessar um membro da classe usando um objeto nulo. Atribuímos o valor de retorno do método initT ao objeto t e, em seguida, acessamos numField usando o objeto t. Mas o objeto t é um objeto nulo, pois initT retorna um objeto nulo. Neste ponto, java.lang.NullPointerException é gerado.

# 3) Passar um objeto nulo como argumento

Esta é a causa comum da ocorrência de java.lang.NullPointerException. Considere o seguinte programa Java. Aqui temos um método ‘print_LowerCase’ que converte o objeto String passado como um argumento para minúsculas.

public class Main { public static void print_LowerCase(String s) { System.out.println(s.toLowerCase()); } public static void main(String() args) { print_LowerCase(null); //pass null object as argument to the method } }

Resultado

objeto nulo como argumento

No método principal, chamamos esse método e passamos um nulo como argumento. Como o objeto String não pode ser nulo, o java.lang.NullPointerException é lançado.

# 4) Obter o comprimento de uma matriz nula

A tentativa de calcular o comprimento de uma matriz nula também resulta em java.lang.NullPointerException sendo lançado.

O programa abaixo demonstra isso.

public class Main { public static void main(String() args) { int() dataArray = null; //Array is null; no data System.out.println('Array Length:' + dataArray.length); //print array length } }

Resultado

comprimento de uma matriz nula

No programa acima, declaramos uma matriz e atribuímos nulo a ela, ou seja, nenhum dado. Quando usamos a propriedade length neste array nulo, NullPointerException é lançado.

# 5) Índice de acesso de uma matriz nula

Semelhante ao comprimento, mesmo se tentarmos acessar um valor em uma matriz nula usando um índice, é a causa de java.lang.NullPointerException.

public class Main { public static void main(String() args) { int() dataArray = null; //Array set to null //access value at index 2 System.out.println('Value at index 2:' + dataArray(2)); } }

Resultado

Índice de acesso de uma matriz nula

No programa acima, tentamos acessar o valor no índice 2 de uma matriz nula.

# 6) Sincronização em um objeto nulo

Normalmente sincronizamos um bloco ou um método para facilitar o acesso simultâneo. No entanto, a referência de objeto que usamos para sincronização não deve ser nula. Se for um objeto nulo, isso resultará em java.lang.NullPointerException.

O programa Java abaixo demonstra isso. Como podemos ver, temos um objeto String ‘mutex’ inicializado como nulo. Então, na função principal, usamos um bloco sincronizado com mutex como a referência do objeto. Como mutex é nulo, java.lang.NullPointerException é gerado.

public class Main { public static String mutex = null; //mutex variable set to null public static void main(String() args) { synchronized(mutex) { //synchronized block for null mutex System.out.println('synchronized block'); } } }

Resultado

Sincronização em um objeto nulo

# 7) Jogando nulo

public class Main { public static void main(String() args) { throw null; //throw null } }

Resultado:

Jogando null

No programa de exemplo acima, em vez de lançar um objeto válido, null é lançado. Isso resulta em exceção de ponteiro nulo.

Evitando a exceção de ponteiro nulo

Agora que vimos as causas da ocorrência de NullPointerException, devemos também tentar evitá-la em nosso programa.

Primeiro, devemos garantir que os objetos que usamos em nossos programas sejam inicializados corretamente para que possamos evitar o uso de objetos nulos que resultam em Exceção de Ponteiro Nulo. Também devemos ter cuidado para que as variáveis ​​de referência usadas no programa sejam apontadas para valores válidos e não adquiram acidentalmente valores nulos.

Além dessas considerações, também podemos ter mais cuidado caso a caso para evitar java.lang.NullPointerException.

Abaixo consideramos alguns casos.

# 1) Comparação de strings com literais

Uma comparação entre a variável de string e um literal (valor real ou elemento do enum) é uma operação muito comum em programas Java. Mas se a variável String que é um objeto for nula, a comparação desse objeto nulo com literais gerará NullPointerException.

Portanto, a solução é invocar o método de comparação do literal em vez do objeto String que pode ser nulo.

O programa a seguir mostra como podemos invocar métodos de comparação de literais e evitar java.lang.NullPointerException.

class Main { public static void main (String() args) { // String set to null String myStr = null; // Checking if myStr is null using try catch. try { if ('Hello'.equals(myStr)) //use equals method with literal System.out.print('Two strings are same'); else System.out.print('Strings are not equal'); } catch(NullPointerException e) { System.out.print('Caught NullPointerException'); } } }

Resultado

Comparação de string com literais

# 2) Verifique os argumentos de um método

Verifique os argumentos do método para garantir que eles não sejam valores nulos. Se os argumentos não estiverem de acordo com a especificação, o código lançará IllegalArgumentException para indicar que os argumentos não são os esperados.

Isso é mostrado no programa Java abaixo.

import java.io.*; class Main { public static void main (String() args) { // set String to empty value String myStr = ''; try { System.out.println('String value:' + myStr); System.out.println('String Length:' + getLength(myStr)); } catch(IllegalArgumentException e) { System.out.println('Exception: ' + e.getMessage()); } // Set String to a proper value and call getLength myStr = 'Far from home'; try { System.out.println('String value:' + myStr); System.out.println('String Length:' + getLength(myStr)); } catch(IllegalArgumentException e) { System.out.println('Exception: ' + e.getMessage()); } // Set String to null and call getLength() myStr = null; try { System.out.println('String value:' + myStr); System.out.println('String Length:' + getLength(myStr)); } catch(IllegalArgumentException e) { System.out.println('Exception: ' + e.getMessage()); } } // Method that returns length of the String public static int getLength(String myStr) { if (myStr == null) //throw Exception if String is null throw new IllegalArgumentException('The String argument cannot be null'); return myStr.length(); } }

Resultado

Verifique os argumentos

# 3) Uso do operador ternário para cuidar de valores nulos

Podemos usar o operador ternário para evitar java.lang.NullPointerException. O operador ternário possui três operadores. A primeira é uma expressão booleana avaliada como verdadeira ou falsa. Se a expressão for verdadeira, o segundo operador será retornado ou o terceiro operador será retornado.

O programa a seguir mostra o uso de um operador ternário para evitar NullPointerException.

import java.io.*; class Main { public static void main (String() args) { // Initialize String with null value String myStr = null; //return a substring for this String using ternary oprator String myVal = (myStr == null) ? '' : myStr.substring(0,5); if(myVal.equals('')) System.out.println('Empty String!!'); else System.out.println('String value: ' + myVal); // Now set a value for String myStr = 'SoftwareTestingHelp'; //return a substring for this String using ternary oprator myVal = (myStr == null) ? '' : myStr.substring(0,8); if(myVal.equals('')) System.out.println('Empty String!!'); else System.out.println('String value: ' + myVal); }

Resultado

Operador Ternário

perguntas frequentes

P # 1) Como faço para corrigir NullPointerException em Java?

Responda: Devemos garantir que todos os objetos usados ​​no programa sejam inicializados corretamente e não tenham valores nulos. Além disso, as variáveis ​​de referência não devem ter valores nulos.

# 2) NullPointerException está marcado ou desmarcado?

Responda: NullPointerException não é uma exceção verificada. É um descendente de RuntimeException e está desmarcado.

# 3) Como faço para interromper NullPointerException?

Responda: Algumas das práticas recomendadas para evitar NullPointerException são:

  • Use o método equals () e equalsIgnoreCase () com String literal em vez de usá-lo no objeto desconhecido que pode ser nulo.
  • Use valueOf () em vez de toString (); e ambos retornam o mesmo resultado.
  • Use a anotação Java @NotNull e @Nullable.

# 4) Qual é o valor nulo em Java?

Responda: Um valor nulo não se refere a nenhum objeto ou variável. É uma palavra-chave e um literal. Ele representa uma referência nula.

# 5) Podemos capturar NullPointerException em Java?

Responda: A exceção java.lang.NullPointerException é uma exceção não verificada e estende a classe RuntimeException. Portanto, não há nenhuma compulsão para o programador capturá-lo.

Conclusão

Neste tutorial, discutimos a NullPointerException em Java. Essa é uma exceção bastante perigosa e geralmente pode aparecer quando menos esperamos. A exceção de ponteiro nulo ocorre principalmente devido ao objeto nulo ou referência nula. Já vimos as causas e maneiras de evitar NullPointerException.

Na medida do possível, o programador deve tentar evitar a ocorrência de exceção de ponteiro nulo em um programa. Como esta é uma exceção de tempo de execução não verificada, devemos ver que ela não ocorre quando o aplicativo está em execução.

=> Visite aqui para aprender Java do zero.

Leitura recomendada

^