Menu

Qu'est-ce que NullPointerException en Java et comment l'éviter

  • Principal
  • Autre
  • Qu'est-ce que NullPointerException en Java et comment l'éviter

what is nullpointerexception java how avoid it

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce tutoriel vous expliquera tout sur l'exception NullPointerException en Java. Nous discuterons des causes de l'exception du pointeur nul et des moyens de l'éviter:

NullPointerException en Java est une exception d'exécution. Java attribue une valeur nulle spéciale à une référence d'objet. Lorsqu'un programme tente d'utiliser une référence d'objet définie sur la valeur nulle, cette exception est levée.

=> Regardez la série de formation Java simple ici.

NullPointerException en Java

Ce que vous apprendrez:

NullPointerException en Java

Si une référence d'objet avec une valeur nulle lève NullPointerException, pourquoi avons-nous besoin d'une valeur nulle?

La valeur nulle est généralement utilisée pour indiquer qu'aucune valeur n'a été affectée à une variable de référence. Deuxièmement, nous avons besoin de valeurs nulles pour les collections telles que les listes liées et les arbres pour indiquer des nœuds nuls. Les modèles de conception tels que les modèles singleton utilisent des valeurs nulles.

Pour conclure, la valeur nulle en Java a de nombreuses utilisations. Une exception de pointeur nul est levée dans des scénarios spécifiques en Java.

Certains des scénarios sont les suivants:

  1. Méthode appelée à l'aide d'un objet nul.
  2. Accéder ou modifier un champ ou un membre de données de l'objet nul.
  3. Passer un objet nul comme argument à une méthode.
  4. Calcul de la longueur d'un tableau nul.
  5. Accès à l'index d'un tableau nul.
  6. Synchroniser un objet nul.
  7. Lancer un objet nul.

L'exception de pointeur nul s'étend de la classe RuntimeException.

La hiérarchie de NullPointerException est donnée ci-dessous.

Hiérarchie de NullPointerException en Java

Comme indiqué dans la hiérarchie ci-dessus, Null Pointer Exception s'étend à partir de RuntimeException qui hérite de la classe d'exception. La classe d'exception à son tour est dérivée de la classe Throwable qui est une sous-classe d'Object.

Causes de l'occurrence de java.lang.NullPointerException

Nous allons maintenant démontrer chacun des scénarios d'occurrence de NullPointerException que nous avons répertoriés ci-dessus.

# 1) La méthode est appelée à l'aide d'un objet nul

Considérez l'exemple de code suivant. Ici, nous avons une classe, MyClass, qui fournit deux méthodes. La première méthode «initT» renvoie un objet nul. Dans la méthode principale, nous créons un objet de MyClass avec un appel à la méthode initT.

Ensuite, nous appelons la méthode d'impression de MyClass. Ici, l'exception java.lang.NullPointerException est lancée lorsque nous appelons la méthode d'impression à l'aide d'un objet 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 } }

Production

invoqué à l

# 2) Champ d'accès d'un objet 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 } }

Production

Champ d

quel est le meilleur téléchargeur vidéo

C'est une autre cause de NullPointerException. Ici, nous essayons d'accéder à un membre de classe en utilisant un objet nul. Nous affectons la valeur de retour de la méthode initT à l'objet t puis accédons à numField à l'aide de l'objet t. Mais l'objet t est un objet nul car initT renvoie un objet nul. À ce stade, java.lang.NullPointerException est déclenchée.

# 3) Passer un objet nul comme argument

C'est la cause commune de l'occurrence de java.lang.NullPointerException. Considérez le programme Java suivant. Nous avons ici une méthode ‘print_LowerCase’ qui convertit l’objet String passé en argument en minuscules.

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

Production

objet nul comme argument

Dans la méthode main, nous appelons cette méthode et passons un null comme argument. Étant donné que l'objet String ne peut pas être nul, l'exception java.lang.NullPointerException est levée.

# 4) Obtenir la longueur d'un tableau nul

Tenter de calculer la longueur d'un tableau nul entraîne également la levée de java.lang.NullPointerException.

Le programme ci-dessous le démontre.

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

Production

longueur d

Dans le programme ci-dessus, nous déclarons un tableau et lui attribuons null, c'est-à-dire pas de données. Lorsque nous utilisons la propriété length sur ce tableau nul, NullPointerException est levée.

# 5) Index d'accès d'un tableau nul

Similaire à length, même si nous essayons d'accéder à une valeur dans un tableau nul à l'aide d'un index, c'est la cause 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)); } }

Production

Index d

Dans le programme ci-dessus, nous essayons d'accéder à la valeur à l'index 2 d'un tableau nul.

# 6) Synchronisation sur un objet nul

Nous synchronisons généralement un bloc ou une méthode pour faciliter l'accès simultané. Cependant, la référence d'objet que nous utilisons pour la synchronisation ne doit pas être nulle. S'il s'agit d'un objet nul, il en résulte java.lang.NullPointerException.

Le programme Java ci-dessous le montre. Comme nous pouvons le voir, nous avons un objet String «mutex» initialisé à null. Ensuite, dans la fonction principale, nous utilisons un bloc synchronisé avec mutex comme référence d'objet. Comme mutex est nul, java.lang.NullPointerException est déclenché.

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

Production

Synchronisation sur un objet nul

# 7) En lançant null

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

Production:

En lançant null

Dans l'exemple de programme ci-dessus, au lieu de lancer un objet valide, null est levé. Cela entraîne une exception de pointeur nul.

Éviter l'exception de pointeur nul

Maintenant que nous avons vu les causes de l'occurrence de NullPointerException, nous devons également essayer de l'éviter dans notre programme.

Tout d'abord, nous devons nous assurer que les objets que nous utilisons dans nos programmes sont correctement initialisés afin que nous puissions éviter l'utilisation d'objets nuls qui entraînent une exception de pointeur nul. Nous devons également veiller à ce que les variables de référence utilisées dans le programme soient pointées vers des valeurs valides et n'acquièrent pas accidentellement des valeurs nulles.

En dehors de ces considérations, nous pouvons également faire preuve de plus de prudence au cas par cas pour éviter l'exception java.lang.NullPointerException.

Ci-dessous, nous considérons quelques cas.

# 1) Comparaison de chaînes avec des littéraux

Une comparaison entre la variable chaîne et un littéral (valeur réelle ou élément de l'énumération) est une opération très courante dans les programmes Java. Mais si la variable String qui est un objet est nulle, la comparaison de cet objet nul avec des littéraux lèvera NullPointerException.

La solution consiste donc à appeler la méthode de comparaison à partir du littéral au lieu de l'objet String qui peut être nul.

Le programme suivant montre comment invoquer des méthodes de comparaison à partir de littéraux et éviter 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'); } } }

Production

Comparaison de chaînes avec des littéraux

# 2) Gardez un œil sur les arguments d'une méthode

Vérifiez les arguments de la méthode pour vous assurer qu'il ne s'agit pas de valeurs nulles. Si les arguments ne sont pas conformes à la spécification, le code lèvera IllegalArgumentException pour indiquer que les arguments ne sont pas comme prévu.

Ceci est illustré dans le programme Java ci-dessous.

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

Production

Gardez un œil sur les arguments

# 3) Utilisation de l'opérateur ternaire pour prendre en charge les valeurs nulles

Nous pouvons utiliser l'opérateur ternaire pour éviter java.lang.NullPointerException. L'opérateur ternaire a trois opérateurs. Le premier est une expression booléenne évaluée à vrai ou faux. Si l'expression est vraie, le deuxième opérateur est renvoyé ou le troisième opérateur est renvoyé.

Le programme suivant montre l'utilisation d'un opérateur ternaire pour éviter 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); }

Production

Opérateur ternaire

Questions fréquemment posées

Q # 1) Comment corriger NullPointerException en Java?

Répondre: Nous devons nous assurer que tous les objets utilisés dans le programme sont correctement initialisés et qu'ils n'ont pas de valeurs nulles. De plus, les variables de référence ne doivent pas avoir de valeurs nulles.

# 2) NullPointerException est-elle cochée ou décochée?

Répondre: NullPointerException n'est pas une exception vérifiée. Il s'agit d'un descendant de RuntimeException et n'est pas coché.

# 3) Comment arrêter NullPointerException?

Répondre: Certaines des meilleures pratiques pour éviter NullPointerException sont:

  • Utilisez les méthodes equals () et equalsIgnoreCase () avec le littéral String au lieu de l'utiliser sur l'objet inconnu qui peut être nul.
  • Utilisez valueOf () au lieu de toString (); et les deux renvoient le même résultat.
  • Utilisez l'annotation Java @NotNull et @Nullable.

# 4) Quelle est la valeur nulle en Java?

Répondre: Une valeur nulle ne fait référence à aucun objet ou variable. C'est un mot-clé et un littéral. Il représente une référence nulle.

# 5) Pouvons-nous attraper NullPointerException en Java?

Répondre: L'exception java.lang.NullPointerException est une exception non vérifiée et étend la classe RuntimeException. Il n'y a donc aucune contrainte pour le programmeur de l'attraper.

Conclusion

Dans ce didacticiel, nous avons discuté de l'exception NullPointerException en Java. C'est une exception assez dangereuse et peut généralement apparaître lorsque nous nous y attendons le moins. L'exception de pointeur nul se produit principalement en raison de l'objet nul ou de la référence nulle. Nous avons déjà vu les causes et les moyens d'éviter NullPointerException.

Dans la mesure du possible, le programmeur doit essayer d'éviter l'apparition d'une exception de pointeur nul dans un programme. Comme il s'agit d'une exception d'exécution non vérifiée, nous devrions voir qu'elle ne se produit pas lorsque l'application est en cours d'exécution.

=> Visitez ici pour apprendre Java à partir de zéro.

lecture recommandée

^