Une NullPointerException en Java est une RuntimeException. Cela se produit lorsqu'un programme tente d'utiliser une référence d'objet ayant la valeur nulle. En Java, « null » est une valeur spéciale qui peut être attribuée aux références d'objet pour indiquer l'absence de valeur.

Raisons de l’exception de pointeur nul

Une NullPointerException se produit pour les raisons suivantes : 

• Appel d'une méthode à partir d'un objet nul.
• Accéder ou modifier le champ d’un objet nul.
• Prendre la longueur de null comme s'il s'agissait d'un tableau.
• Accéder ou modifier les emplacements des objets nuls comme s'il s'agissait d'un tableau.
• Lancer null comme s'il s'agissait d'une valeur Throwable.
• Lorsque vous essayez de synchroniser sur un objet nul.

Exemple:

type de date dactylographié

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

Sortir:

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

Explication: Dans cet exemple, la référence de chaîne « s » est nulle. Lorsque le programme tente d'appeler la méthode length(), il lève une NullPointerException car il n'y a pas d'objet réel.

commande git push

Pourquoi null est-il utilisé en Java ?

La valeur nulle sert d'espace réservé et indique qu'aucune valeur n'est attribuée à une variable de référence. Les applications courantes incluent :

• Structures de données liées : Il représente la fin d’une liste ou d’une branche d’arbre.
• Modèles de conception : Ceci est utilisé dans des modèles tels que le modèle d'objet nul ou le modèle Singleton.

Comment éviter NullPointerException

Pour éviter l'exception NullPointerException, nous devons nous assurer que tous les objets sont correctement initialisés avant de les utiliser. Lorsque nous déclarons une variable de référence, nous devons vérifier que l'objet n'est pas nul avant de demander une méthode ou un champ aux objets.

1. Utilisation de chaînes littérales dans equals()

Un problème très courant implique la comparaison entre une variable String et un littéral. Le littéral peut être une chaîne ou un élément d'une énumération. Au lieu d'invoquer la méthode à partir de l'objet nul, envisagez de l'invoquer à partir du littéral. 

Exemple:

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

Nous pouvons éviter NullPointerException en appelant égal au littéral plutôt qu'à l'objet.

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

Note : Invoquez toujours égal sur le littéral pour éviter d'appeler une méthode sur une référence nulle.

2. Vérification des arguments de la méthode

Avant d'exécuter le corps de la nouvelle méthode, nous devons d'abord vérifier ses arguments pour les valeurs nulles et continuer l'exécution de la méthode uniquement lorsque les arguments sont correctement vérifiés. Sinon, il lancera une IllegalArgumentException et informera la méthode appelante que quelque chose ne va pas avec les arguments passés. 

xd xd signification

Exemple:

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. Utiliser l'opérateur ternaire

L'opérateur ternaire peut être utilisé pour éviter NullPointerException. L’expression booléenne est d’abord évaluée. Si l'expression est vraie alors la valeur1 est renvoyée sinon la valeur2 est renvoyée. Nous pouvons utiliser l'opérateur ternaire pour gérer les pointeurs nuls.

Exemple:

qu'est-ce que l'expression régulière Java

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 

Explication : L'opérateur ternaire permet de vérifier la valeur NULL et d'éviter les opérations sur les références NULL.

4. Utilisation de la classe facultative (Java 8+)

Dans Java 8, la classe facultative a été introduite en tant qu'objet conteneur pouvant ou non contenir une valeur non nulle. Cela permet d'éviter NullPointerException en forçant à traiter explicitement le cas où une valeur est absente.

Exemple:

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 

Explication: Facultatif.ofNullable(value) encapsule la valeur qui pourrait être nulle. orElse() fournit une solution de secours si la valeur n'est pas présente.