Exception de pointeur nul en Java
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:
Java 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.
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:
Java 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' ); } } }
Sortir
NullPointerException Caught
Nous pouvons éviter NullPointerException en appelant égal au littéral plutôt qu'à l'objet.
Java 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' ); } } }
Sortir
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.
Exemple:
Java 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 (); } }
Sortir
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:
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 ); } }
Sortir
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:
Java 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 } }
Sortir
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.
