Presque tous les langages de programmation sont liés à null. Il n’y a pratiquement aucun programmeur qui ne soit pas gêné par null. En Java, null est associé à java.lang. NullPointerException . Comme il s'agit d'une classe du package java.lang, elle est appelée lorsque nous essayons d'effectuer certaines opérations avec ou sans null et parfois nous ne savons même pas où cela s'est produit. Vous trouverez ci-dessous quelques points importants sur null en Java que tout programmeur Java devrait connaître : 

première recherche en profondeur de l'algorithme

• En Java, null est une valeur spéciale qui représente l'absence de valeur ou de référence. Il est utilisé pour indiquer qu’une variable ou un objet n’a actuellement aucune valeur qui lui est attribuée.
• La valeur nulle n'est pas la même chose qu'une chaîne vide ou un tableau vide. Une chaîne vide est une chaîne qui ne contient aucun caractère tandis qu'un tableau vide est un tableau qui ne contient aucun élément.
• Le langage de programmation Java possède un type nul intégré appelé « null » qui est un sous-type de tous les types de référence. Cependant, il ne peut pas être utilisé comme type pour une variable car il n'a aucune instance et ne peut pas être instancié.
• Il est considéré comme une bonne pratique de vérifier les valeurs nulles avant d’effectuer toute opération sur celles-ci afin d’éviter le risque d’une NullPointerException (NPE). NPE est considéré comme l'une des exceptions les plus courantes en Java et peut provoquer un comportement inattendu ou des plantages dans un programme.
• En Java, null est également utilisé pour indiquer qu'une méthode ne renvoie aucune valeur. C'est ce qu'on appelle un type de retour « vide ». Une méthode void ne renvoie aucune valeur et est généralement utilisée pour effectuer une action telle que l'impression sur la console ou la mise à jour d'une base de données.
• De plus, null peut être utilisé comme valeur par défaut pour les paramètres facultatifs d'une méthode. Cela permet d'appeler une méthode sans spécifier de valeur pour ce paramètre et la valeur nulle sera utilisée à la place.
• Il n'est pas recommandé d'utiliser null comme valeur pour une variable ou un objet destiné à contenir une valeur d'un type de données primitif tel que int ou double, car cela provoquerait une erreur de compilation.
• L'utilisation de null en Java peut être une source de confusion et de bugs subtils, il est donc important d'être conscient de son comportement et de savoir comment le gérer correctement dans votre code pour éviter les erreurs.

1. null est sensible à la casse : null est littéral en Java et parce que les mots-clés sont sensible aux majuscules et minuscules en java on ne peut pas écrire NULL ou 0 comme en langage C. 

public class Test {  public static void main (String[] args) throws java.lang.Exception  {  // compile-time error : can't find symbol 'NULL'  Object obj = NULL;     //runs successfully  Object obj1 = null;   } } 

Sortir:

5: error: cannot find symbol  
 can't find symbol 'NULL'  
 ^  
 variable NULL  
 class Test  
1 error 

2. Valeur de la variable de référence : Toute variable de référence en Java a une valeur par défaut nul . 

public class Test {  private static Object obj;   public static void main(String args[])  {  // it will print null;  System.out.println("Value of object obj is : " + obj);  }  } 

Sortir:

Value of object obj is : null 

3. Type de nul : Contrairement à l’idée fausse courante, null n’est ni un objet ni un type. C'est juste une valeur spéciale qui peut être attribuée à n'importe quel type de référence et vous pouvez taper cast null en n'importe quel type. Exemples :

 // null can be assigned to String  
 String str = null;   
   
 // you can assign null to Integer also  
 Integer itr = null;   
   
 // null can also be assigned to Double  
 Double dbl = null;   
   
 // null can be type cast to String  
 String myStr = (String) null;   
   
 // it can also be type casted to Integer  
 Integer myItr = (Integer) null;   
   
 // yes it's possible no error  
 Double myDbl = (Double) null; 

4. Autoboxing et unboxing : Pendant les opérations de boxing automatique et de déballage, le compilateur renvoie simplement une erreur d'exception Nullpointer si une valeur nulle est attribuée au type de données en boîte primitif. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  // An integer can be null so this is fine  Integer i = null;  // Unboxing null to integer throws  // NullpointerException  int a = i;  } } 

Sortir:

 Exception in thread 'main' java.lang.NullPointerException  
 at Test.main(Test.java:6) 

5. opérateur instanceof : L'opérateur java instanceof est utilisé pour tester si l'objet est une instance du type spécifié (classe ou sous-classe ou interface). Au moment de l'exécution, le résultat de l'opérateur instanceof est vrai si la valeur de l'expression n'est pas nulle. Il s'agit d'une propriété importante de instanceof operation qui la rend utile pour les vérifications de transtypage de type. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  Integer i = null;  Integer j = 10;  // prints false  System.out.println(i instanceof Integer);  // Compiles successfully  System.out.println(j instanceof Integer);  } } 

Sortir:

false   
true

6. Méthodes statiques ou non statiques : Nous ne pouvons pas appeler une méthode non statique sur une variable de référence avec une valeur nulle, cela lancera NullPointerException mais nous pouvons appeler une méthode statique avec des variables de référence avec des valeurs nulles. Étant donné que les méthodes statiques sont liées à l’aide d’une liaison statique, elles ne lanceront pas d’exception de pointeur Null. 

public class Test {  public static void main(String args[])  {  Test obj = null;  obj.staticMethod();  obj.nonStaticMethod();  }  private static void staticMethod()  {  // Can be called by null reference  System.out.println(  " static method  can be called by null reference & quot;);  }  private void nonStaticMethod()  {  // Can not be called by null reference  System.out.print("  Non - static method - ");  System.out.println(  "  cannot be called by null reference & quot;);  } } 

Sortir:

static method can be called by null referenceException in thread 'main'   
java.lang.NullPointerException  
 at Test.main(Test.java:5) 

7. == et != La comparaison et les opérateurs non égaux à sont autorisés avec null en Java. Cela peut être utile pour vérifier null avec des objets en Java. 

public class Test {  public static void main(String args[])  {  // return true;  System.out.println(null == null);  // return false;  System.out.println(null != null);  } } 

Sortir:

true  
false

8 . 'null' peut être passé en argument dans la méthode :

Nous pouvons passer le null comme argument en Java et nous pouvons l’imprimer. Le type de données de l’argument doit être Type de référence. Mais le type de retour de la méthode peut être n'importe quel type comme void int double ou tout autre type de référence en fonction de la logique du programme.

Ici, la méthode 'print_null' imprimera simplement l'argument transmis par la méthode principale.

import java.io.*; class GFG {  public static void print_null(String str)  {  System.out.println('Hey I am : ' + str);  }  public static void main(String[] args)  {  GFG.print_null(null);  } } 

Sortir :

Hé, je suis : nul

9. Opérateur '+' sur null :

Nous pouvons concaténer la valeur nulle avec des variables String en Java. C'est considéré comme une concaténation en Java.

Ici, le null ne sera concaténé qu'avec la variable String. Si nous utilisons l'opérateur '+' avec null et tout autre type (Integer Double, etc.) autre que String, un message d'erreur sera généré. 

L'entier a=null+7 générera un message d'erreur comme ' mauvais types d'opérandes pour l'opérateur binaire '+' '

import java.io.*; class GFG {  public static void main(String[] args)  {  String str1 = null;  String str2 = '_value';  String output = str1 + str2;  System.out.println('Concatenated value : '  + output);  } } 

Concatenated value : null_value