Menú

Què és NullPointerException a Java i com evitar-ho

what is nullpointerexception java how avoid it

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explicarà tot sobre l'excepció NullPointerException a Java. Discutirem les causes de l'excepció del punter nul i maneres d'evitar-ho:

NullPointerException a Java és una excepció en temps d'execució. Java assigna un valor nul especial a una referència d'objecte. Quan un programa intenta utilitzar una referència d’objecte establerta al valor nul, es genera aquesta excepció.

=> Vigileu aquí les sèries de formació Java senzilles.

NullPointerException a Java

Què aprendreu:

NullPointerException a Java

Si una referència d’objecte amb valor nul genera NullPointerException, per què necessitem un valor nul?

El valor nul s’utilitza normalment per indicar que no s’ha assignat cap valor a una variable de referència. En segon lloc, necessitem valors nuls per a col·leccions com ara llistes enllaçades i arbres per indicar nodes nuls. Els patrons de disseny com els patrons singleton fan servir valors nuls.

Per concloure, el valor nul a Java té molts usos. L'excepció de punter nul es genera en escenaris específics de Java.

Alguns dels escenaris són els següents:

  1. Mètode invocat mitjançant un objecte nul.
  2. Accedir o modificar un camp o membre de dades de l'objecte nul.
  3. Passar objecte nul com a argument a un mètode.
  4. Càlcul de la longitud d'una matriu nul·la.
  5. Accés a l'índex d'una matriu nul·la.
  6. Sincronització d’un objecte nul.
  7. Llançar un objecte nul.

L'excepció Null Pointer s'estén des de la classe RuntimeException.

A continuació es mostra la jerarquia de NullPointerException.

Jerarquia de NullPointerException a Java

Com es mostra a la jerarquia anterior, Null Pointer Exception s’estén des de RuntimeException que hereta la classe d’excepcions. Al seu torn, la classe d’excepció es deriva de la classe Throwable que és una subclasse d’Objecte.

Causes de l'aparició de java.lang.NullPointerException

Ara demostrarem cadascun dels escenaris d’ocurrència de NullPointerException que hem enumerat anteriorment.

# 1) El mètode s'invoca mitjançant un objecte nul

Penseu en el següent exemple de codi. Aquí tenim una classe, MyClass, que proporciona dos mètodes. El primer mètode 'initT' retorna un objecte nul. Al mètode principal, creem un objecte de MyClass amb una trucada al mètode initT.

A continuació, anomenem el mètode d'impressió de MyClass. Aquí es llança java.lang.NullPointerException mentre anomenem el mètode d’impressió mitjançant un objecte nul.

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 } }

Sortida

invocat mitjançant un objecte nul

# 2) Camp d'accés d'un objecte nul

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 } }

Sortida

Camp d

com obrir fitxers bin Windows 10

Aquesta és una altra causa de l'excepció NullPointerEx. Aquí intentem accedir a un membre de la classe mitjançant un objecte nul. Assignem el valor de retorn del mètode initT a l'objecte t i després accedim a numField mitjançant l'objecte t. Però l'objecte t és un objecte nul, ja que initT retorna un objecte nul. En aquest moment, es genera java.lang.NullPointerException.

# 3) Passar un objecte nul com a argument

Aquesta és la causa comuna de l’aparició de java.lang.NullPointerException. Penseu en el següent programa Java. Aquí tenim un mètode ‘print_LowerCase’ que converteix l’objecte String passat com a argument en minúscula.

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 } }

Sortida

objecte nul com a argument

Al mètode principal, anomenem aquest mètode i passem un valor nul com a argument. Com que l'objecte String no pot ser nul, es llança java.lang.NullPointerException.

# 4) Obtenir la longitud d'una matriu nul·la

Si intenteu calcular la longitud d'una matriu nul·la, també es produeix java.lang.NullPointerException.

El programa següent ho demostra.

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 } }

Sortida

longitud d

Al programa anterior, declarem una matriu i li assignem nul·la, és a dir, no hi ha dades. Quan fem servir la propietat de longitud en aquesta matriu nul·la, es llença NullPointerException.

# 5) Índex d’accés d’una matriu nul·la

De manera similar a la longitud, fins i tot si intentem accedir a un valor en una matriu nul·la mitjançant un índex, és la 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)); } }

Sortida

Índex d’accés d’una matriu nul·la

Al programa anterior, intentem accedir al valor de l’índex 2 d’una matriu nul·la.

# 6) Sincronització en un objecte nul

Normalment sincronitzem un bloc o un mètode per facilitar l'accés simultani. Tanmateix, la referència d’objecte que fem servir per a la sincronització no ha de ser nul·la. Si és un objecte nul, donarà lloc a java.lang.NullPointerException.

El programa Java següent ho demostra. Com podem veure, tenim un objecte String ‘mutex’ inicialitzat a nul. A continuació, a la funció principal, fem servir un bloc sincronitzat amb mutex com a referència de l'objecte. Com que mutex és nul, es genera java.lang.NullPointerException.

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'); } } }

Sortida

Sincronització en un objecte nul

# 7) Llançament nul

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

Sortida:

En llançar nul

En el programa d'exemple anterior, en lloc de llançar un objecte vàlid, es llença nul. Això es tradueix en una excepció del punter nul.

Evitar l'excepció del punter nul

Ara que hem vist les causes de l'aparició de NullPointerException, també hem d'intentar evitar-ho al nostre programa.

En primer lloc, hem d’assegurar-nos que els objectes que fem servir als nostres programes s’inicialitzen correctament per tal d’evitar l’ús d’objectes nuls que resultin en l’excepció del punter nul. També hem de procurar que les variables de referència que s’utilitzen al programa s’assenyalin a valors vàlids i no adquireixin accidentalment valors nuls.

A part d’aquestes consideracions, també podem tenir més precaució cas per cas per evitar java.lang.NullPointerException.

A continuació, considerem alguns casos.

# 1) Comparació de cadenes amb literals

Una comparació entre la variable de cadena i un literal (valor real o element de l'enum) és una operació molt comuna en els programes Java. Però si la variable String que és un objecte és nul·la, comparar aquest objecte nul amb els literals generarà NullPointerException.

Per tant, la solució és invocar el mètode de comparació des del literal en lloc de l’objecte String que pot ser nul.

El programa següent mostra com podem invocar mètodes de comparació a partir de literals i 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'); } } }

Sortida

Comparació de cadenes amb literals

# 2) Comproveu els arguments d’un mètode

Comproveu els arguments del mètode per assegurar-vos que no siguin valors nuls. Si els arguments no són segons l'especificació, el codi llançarà IllegalArgumentException per indicar que els arguments no són els esperats.

Això es mostra al programa Java següent.

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(); } }

Sortida

Comproveu els arguments

# 3) Ús de l'operador ternari per tenir cura dels valors nuls

Podem utilitzar l’operador ternari per evitar java.lang.NullPointerException. L'operador ternari té tres operadors. La primera és una expressió booleana que es valora com a veritable o falsa. Si l'expressió és certa, es torna el segon operador o es torna el tercer operador.

El programa següent mostra l'ús d'un operador ternari per 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); }

Sortida

Operador ternari

Preguntes freqüents

P # 1) Com puc solucionar NullPointerException a Java?

Resposta: Hem d’assegurar-nos que tots els objectes que s’utilitzen al programa s’inicialitzen correctament i no tenen valors nuls. A més, les variables de referència no haurien de tenir valors nuls.

# 2) NullPointerException està marcada o desmarcada?

Resposta: NullPointerException no és una excepció marcada. És un descendent de RuntimeException i no està marcat.

# 3) Com puc aturar NullPointerException?

Resposta: Algunes de les pràctiques recomanades per evitar NullPointerException són:

  • Utilitzeu el mètode equals () i equalsIgnoreCase () amb String literal en lloc d’utilitzar-lo a l’objecte desconegut que pot ser nul.
  • Utilitzeu valueOf () en lloc de toString (); i tots dos retornen el mateix resultat.
  • Utilitzeu l’anotació Java @NotNull i @Nullable.

# 4) Quin és el valor nul a Java?

Resposta: Un valor nul no fa referència a cap objecte ni variable. És una paraula clau i un literal. Representa una referència nul·la.

# 5) Podem detectar NullPointerException a Java?

Resposta: L'excepció java.lang.NullPointerException és una excepció sense comprovar i amplia la classe RuntimeException. Per tant, no hi ha cap obligació perquè el programador l’atrapi.

Conclusió

En aquest tutorial, hem parlat de l'excepció NullPointerException a Java. Aquesta és una excepció força perillosa i normalment pot aparèixer quan menys ho esperem. L'excepció de punter nul es dóna principalment a causa de l'objecte nul o la referència nul·la. Ja hem vist les causes i maneres d’evitar NullPointerException.

En la mesura del possible, el programador hauria d’intentar evitar l’aparició de l’excepció de punter nul en un programa. Com que es tracta d’una excepció de temps d’execució sense comprovar, hauríem de veure que no es produeix quan s’aplica l’aplicació.

=> Visiteu aquí per aprendre Java des de zero.

Lectura recomanada

^