Java NullPointerException

NullPointer Exception est une exception en Java qui survient très fréquemment chez les programmeurs. Il s'agit d'une exception d'exécution qui se produit lorsque l'instanciation de l'objet n'est pas correcte. L'objet est déclaré comme ayant une valeur nulle. L'exception du pointeur nul signifie simplement qu'il essaie d'appeler un objet avec une référence contenant une valeur nulle. La chose la plus importante à garder à l’esprit est que l’exception du pointeur nul n’est pas liée aux pointeurs car le langage Java ne prend pas en charge le concept de pointeur ; il est plutôt associé à des références d'objets.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

Il n'y a pas de syntaxe spécifique pour que l'exception de pointeur Null soit spécifiée comme une erreur d'exécution ; il apparaît automatiquement et devient visible pour l'utilisation.

Une exception catch peut être déclarée puis lancée pour pointer et déboguer l'exception NullPointer. C'est une chose très fastidieuse à déboguer pour NullPointerException. Il est nécessaire de s'assurer que l'instanciation de l'objet et la déclaration de référence sont correctes au moment de l'exécution.

try {
Object obj1 = new Object(); // Instantiate a new object for the class as reference
Obj1=null; //Provide null value to the object created
Logging.log(String.format(“get the object value”, obj1.object1for reference));
}
catch(java.lang.NullPointerException exception)
{
Logging.log(exception);
}
catch(Throwable exception)
{
Logging.log(exception,false);
}

Comment fonctionne NullPointerException en Java ?

NullPointerException en Java est une exception qui n'est pas du tout une erreur préférable pour un développeur. Il est très difficile de trouver l’exception car elle se produit à chaque fois lors de l’exécution. Par conséquent, trouver une telle exception est une tâche fastidieuse. Il faut des heures aux programmeurs pour découvrir l'exception NullPointerException.

Cela se produit lorsqu'une tentative inhabituelle est faite pour attribuer l'objet défini avec la valeur null n'importe où alors qu'un objet est requis pour autre chose. Toutes les erreurs Java, y compris NullPointerException, se produisent pour certaines raisons telles que :

• Chaque fois que java.lang.the throwable interface est déclarée, elle générera toutes les erreurs Java possibles et sera étendue par la classe héritée.
• lang.Exception hérite ensuite de java.lang.throwable.
• La classe lang.throwable étend la java.lang.exception.
• Même Java.lang.RuntimeException se produit également en raison de cette classe héritée.
• Finalement, java.lang.NullPointerException est héritée de la classe java.lang.RuntimeException.

Comme il est clairement mentionné et visible que l'exception NullPointerException est héritée de l'exception java.lang.RuntimeException, ce problème surviendra chaque fois qu'il y aura une exécution de l'application au moment de la compilation et de l'exécution de l'application. De plus, chaque fois que l'on tente d'accéder directement à un champ, une méthode ou à la référence incorrecte de l'objet au moment de l'instanciation, il est alors indispensable de lancer l'exception java.lang.NullPointerException. L'ajout d'enregistreurs, puis la création d'un autre objet factice, puis l'appel de l'instance de la méthode de l'objet attribué nul aident également à déboguer correctement le code et à trouver la cause première de NullPointerException et les lignes pointant vers l'erreur et l'exception. Il s'agit donc d'une méthode très conventionnelle de dépannage et de débogage pour comprendre l'erreur Java se produisant sur une ligne spécifique.

Constructeurs de Java NullPointerException

Il existe certains constructeurs spécifiques définis et déclarés avec la méthode NullPointerException, qui sont les suivants :

1. NullPointerException()

Ce constructeur est utilisé pour construire une NullPointerException sans message ni explication détaillés. Cela peut être considéré comme une exception vide ou nulle qui n'est pas aussi recommandée selon les exigences.

2. NullPointerException(String s)

Ce constructeur se comporte de manière contradictoire par rapport à NullPointerException() car il inclut une partie du message détaillé provoqué à l'emplacement spécifié, et il impliquera l'argument qui peut être utilisé au moment de la construction d'une exception de pointeur nul. L'argument String s est responsable de la création de l'exception de pointeur nul avec le message détaillé.

Exemples d'implémentation de Java NullPointerException

Vous trouverez ci-dessous des exemples de Java NullPointerException :

Exemple n°1

Ce programme est utilisé pour démontrer l'invocation d'une méthode non valide au moment de l'exécution, ce qui entraîne une NullPointerException, ce qui n'est pas requis.

Code :

public class Null_Pointer_Excptn {
public static void main(String[] args) {
String strng = null;
try
{
if (strng.equals("monkey"))
System.out.println("Let us take a value which needs to be similar");
else
System.out.println("Otherwise it will not take a similar and equal value.");
}
catch(NullPointerException e)
{
System.out.println("It is a need to catch the null pointer exception.");
}
}
}

Sortie :

Exemple n°2

Ce programme illustre le programme java, qui évite la création de NullPointerException car ce n'est pas une méthode conventionnelle.

Code :

public class Null_Pointer_Excptn_Avoid {
public static void main(String[] args) {
String strng2 = null;
try
{
if ("avoid_null".equals(strng2))
System.out.println("Coming out to be equal");
else
System.out.println("It is not at all coming out to be equal");
}
catch(NullPointerException e)
{
System.out.println("Catch the null pointer Exception to get a clarification.");
}
}
}

Sortie :

Example #3

This program illustrates that the NullPointerException can be avoided using the proper object verification before initialization.

Code:

public class Good_Null_Pntr_Excpn {
public static void main(String[] args) {
String store = "Learning";
try
{
System.out.println(getLength(store));
}
catch(IllegalArgumentException e)
{
System.out.println("Need to catch the definition of illegalArgument.");
}
store = "Educba";
try
{
System.out.println(getLength(store));
}
catch(IllegalArgumentException e)
{
System.out.println("Need to catch the definition of illegalArgument.");
}
store = null;
try
{
System.out.println(getLength(store));
}
catch(IllegalArgumentException e)
{
System.out.println("Need to catch the definition of illegalArgument.");
}
}
public static int getLength(String store)
{
if (store == null)
throw new IllegalArgumentException("Need to catch the definition of illegalArgument.");
return store.length();
}
}

Output:

How to Avoid NullPointerException?

As it is not a good practice to get NullPointerException as it makes the entire codebase cumbersome and consumes time for the programmers to figure out the root cause of the NullPointerException.

Therefore, it is very much needed to avoid these exceptions which can make sure using the following ways:

• By comparing a string with the literals.
• By keeping a check on the passed arguments or parameters being passed from the method.
• By making use of the ternary operator.

Conclusion

Java NullPointerException is an exception which is not a good option and is recommended not to occur as it consumes a lot of time. Debugging and troubleshooting become difficult; therefore, it must keep in mind that before the initialization of the object, the reference of the object must be proper. Therefore, the reference of the object’s null value should be proper, and then it can be avoided.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!