9 choses à propos de NULL en Java

Java et null vont de pair. Il n'y a pratiquement aucun programmeur Java qui n'ait pas rencontré une " exception de pointeur nul " et c'est une triste réalité. Même l'inventeur du concept « nul » l'a qualifié d'erreur d'un milliard de dollars, alors pourquoi Java le prend-il en charge ? null existe depuis longtemps, et je suppose que les créateurs de Java savent que cela crée plus de problèmes qu'il n'en résout, alors pourquoi le supportent-ils encore. Et cela me surprend encore plus parce que la philosophie de Java a été de simplifier les choses, c'est pourquoi ils ne plaisantent plus avec les pointeurs, la surcharge d'opérateurs et l'héritage multiple, mais pourquoi null ? Eh bien, je ne connais pas vraiment la réponse à cette question, mais ce que je sais, c'est que peu importe à quel point null est critiqué par les programmeurs Java et la communauté open source, nous devons vivre avec. Au lieu de le regretter, il vaut mieux en savoir plus et être sûr que nous utilisons null correctement.

Pourquoi devriez-vous en apprendre davantage sur null en Java ?

Parce que si vous ne faites pas attention à null, vous pouvez être sûr que Java vous fera terriblement souffrir java.lang.NullPointerExceptionet vous apprendrez votre leçon, mais vous irez jusqu'au bout. Écrire du code résistant aux plantages est un art et votre équipe, vos clients et vos utilisateurs l'apprécieront. D'après mon expérience, l'une des principales raisons NullPointerExceptionest le manque de connaissances sur null en Java. Beaucoup d'entre vous connaissent déjà null, le reste d'entre vous pourra apprendre des choses anciennes et nouvelles sur le mot-clé null. Passons en revue ou apprenons quelques choses importantes sur null en Java.

Qu'est-ce qui est nul en Java

Comme je l'ai dit, null est un concept très, très important en Java. Il a été inventé à l'origine pour indiquer l'absence de quelque chose, comme l'absence d'un utilisateur, d'une ressource ou autre, mais il a intrigué les programmeurs Java avec de nombreux null pointer exception. Dans ce didacticiel, nous apprendrons les faits de base sur le mot-clé null en Java et quelques astuces pour éviter les problèmes null pointer exceptionset minimiser les vérifications nulles.

1. Tout d’abord, null est un mot-clé en Java, tout comme public, staticou final. La casse est sensible, vous ne pouvez pas écrire null comme Null ou NULL, le compilateur ne le reconnaîtra pas et une erreur sera générée.

   Object obj = NULL; // Not Ok
   Object obj1 = null //Ok

   Ceci est souvent rencontré par les programmeurs qui ont quitté d'autres langages de programmation, mais lors de l'utilisation d'IDE modernes, le problème devient insignifiant. De nos jours, les IDE comme Eclipse ou NetBeans peuvent corriger cette erreur pendant que vous tapez, mais à l'ère de Notepad, Vim et Emacs, il s'agissait d'un problème courant qui pouvait prendre beaucoup de temps précieux.

2. Tout comme chaque primitive a une valeur par défaut, par exemple int0, booléen est faux, null est la valeur par défaut de tous les types référence, en d'autres termes, pour tous les objets. Tout comme lorsque vous créez une variable booléenne, sa valeur par défaut est false, toutes les variables de référence en Java prendront par défaut la valeur null. Cela est vrai pour tous les types de variables : variable membre ou variable locale, variable d'instance ou variable statique, et le compilateur se plaindra si vous utilisez une variable locale sans l'initialiser.

   private static Object myObj;
   public static void main(String args[]){
       System.out.println("What is value of myObjc : " + myObj);
   }
   What is value of myObjc : null

   Cela est vrai pour les objets statiques et non statiques, comme vous pouvez le voir ici, j'en ai fait une myObjréférence statique afin de pouvoir l'utiliser directement dans une méthode main, qui est une méthode statique et ne permet pas d'accéder aux variables non statiques. intérieurement.

3. Malgré une idée fausse courante, null n'est ni un objet ( Object) ni un type. Il s'agit simplement d'une valeur spéciale qui peut être attribuée à n'importe quel type de référence, et vous pouvez convertir null en n'importe quel type, comme indiqué ci-dessous :

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

   Comme vous pouvez le voir, la conversion de null en n'importe quel type de référence réussira à la fois au moment de la compilation et au moment de l'exécution. Contrairement à ce que beaucoup d’entre vous ont pu penser, cela n’entraînera pas de gaspillage NullPointerException.

4. null ne peut être affecté qu'à un type référence ; vous ne pouvez pas affecter null à une variable primitive telle que int, double, floatou boolean. Le compilateur exprimera son mécontentement à votre égard si vous procédez comme indiqué ci-dessous :

   int i = null; // type mismatch : cannot convert from null to int
   short s = null; // type mismatch : cannot convert from null to short
   byte b = null: // type mismatch : cannot convert from null to byte
   double d = null; //type mismatch : cannot convert from null to double
   
   Integer itr = null; // this is ok
   int j = itr; // this is also ok, but NullPointerException at runtime

   Comme vous pouvez le voir, lorsque nous attribuons directement null à une primitive, nous obtenons une erreur de compilation, mais si nous attribuons null à un objet de classe wrapper puis attribuons cet objet au type primitif correspondant, le compilateur ne répondra pas, mais nous le ferons être récompensé null pointer exceptionau moment de l'exécution. Cela est dû à l'autoboxing ( autoboxing) en Java, et nous en verrons plus dans la section suivante.

5. Toute classe wrapper avec une valeur nulle sera levée java.lang.NullPointerExceptionlorsque Java unboxla déballera dans une variable primitive. Certains programmeurs font l'erreur de supposer qu'autoboxing( autoboxing) se chargera de convertir null en valeur par défaut pour le type primitif correspondant, comme 0 pour int, false pour booleanetc., mais ce n'est pas vrai, comme vous pouvez le voir ci-dessous :

   Integer iAmNull = null;
   int i = iAmNull; // Remember - No Compilation Error

   Mais lorsque vous exécuterez ce morceau de code, vous verrez dans la console

   Exception in thread "main" java.lang.NullPointerException

   Cela arrive souvent lorsque vous travaillez avec HashMapet Integer key. Le code ci-dessous s'abandonnera dès que vous l'exécuterez.

   import java.util.HashMap;
   import java.util.Map;
   /**
   * An example of Autoboxing and NullPointerExcpetion
   *
   * @author WINDOWS 8
   */
   public class Test {
       public static void main(String args[]) throws InterruptedException {
           Map numberAndCount = new HashMap<>();
           int[] numbers = {3, 5, 7,9, 11, 13, 17, 19, 2, 3, 5, 33, 12, 5};
           for(int i : numbers){
               int count = numberAndCount.get(i);
               numberAndCount.put(i, count++); // NullPointerException here
           }
       }
   }

   
   

   Output: Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:25)

   Ce code semble très simple et inoffensif. Il vous suffit de compter combien de fois un nombre apparaît dans un tableau, une technique classique pour rechercher des doublons. Le développeur prend la quantité comptée précédente, l'augmente de un et la réinsère dans Map. Il pourrait penser que l'auto-boxing se chargera de la conversion Integeren int, comme c'est le cas lorsque la méthode est appelée put(), mais il oublie que si le nombre n'a pas encore été compté, la méthode get()retournera HashMapnull, et non zéro, car la valeur par défaut est Integer, c'est null, pas 0, et la boxe automatique sera lancée null pointer exceptionlors de la tentative de conversion d'un Integer en variable int.

6. L'opérateur instanceofrenverra false si une variable de référence avec la valeur null ou null elle-même est spécifiée en tant que paramètre. Exemple:

   Integer iAmNull = null;
   if(iAmNull instanceof Integer){
       System.out.println("iAmNull is instance of Integer");
   }else{
       System.out.println("iAmNull is NOT an instance of Integer");
   }

   
   

   Output : iAmNull is NOT an instance of Integer

   Il s'agit d'une propriété importante de l'opérateur instanceofqui le rend utile pour tester les conversions de type.

7. Vous savez que vous ne pouvez pas appeler une méthode non statique sur une variable de référence nulle, elle appellera NullPointerException, mais vous ne savez peut-être pas que vous pouvez appeler une méthode statique sur une variable de référence nulle. Parce que les méthodes statiques utilisent une liaison statique, elles ne jettent pas les fichiers NullPointerException. Voici un exemple :

   public class Testing {
       public static void main(String args[]){
           Testing myObject = null;
           myObject.iAmStaticMethod();
           myObject.iAmNonStaticMethod();
       }
       private static void iAmStaticMethod(){
           System.out.println("I am static method, can be called by null reference");
       }
       private void iAmNonStaticMethod(){
           System.out.println("I am NON static method, don't date to call me by null");
       }
   }

   
   

   Output: I am static method, can be called by null reference
   Exception in thread "main" java.lang.NullPointerException
   at Testing.main(Testing.java:11)

8. Vous pouvez transmettre null en tant que paramètre à une méthode qui accepte n'importe quel type de référence, par exemple :

   public void print(Object obj)

   peut être appelé comme

   print(null)

   C'est normal du point de vue du compilateur, mais le comportement ultérieur dépend entièrement de la méthode. Une méthode null-safe ne lancera pas NullPointerException, mais se terminera simplement gracieusement. Si la logique métier le permet, il est recommandé d’écrire des méthodes null-safe.

9. Vous pouvez comparer null en utilisant les opérateurs ==(égal) et !=(pas égal), mais vous ne pouvez pas l'utiliser avec d'autres opérateurs arithmétiques ou logiques comme <(inférieur à) ou >(supérieur à). Contrairement à SQL, Java null == nullrenvoie true comme indiqué ci-dessous :

   public class Test {
   	public static void main(String args[]) throws InterruptedException {
   		String abc = null;
   		String cde = null;
   		if(abc == cde){
   			System.out.println("null == null is true in Java");
   		}
   		if(null != null){
   			System.out.println("null != null is false in Java");
   		}
   		// classical null check
   		if(abc == null){
   			// do something
   		}
   		// not ok, compile time error
   		if(abc > null){
   
   		}
   	}
   }

   
   

   Output:
   null == null is true in Java

Tout est question de null en Java. En acquérant une certaine expérience en programmation Java et en utilisant des astuces simples pour éviter les erreurs NullPointerException, vous pouvez sécuriser votre code. Parce que null peut être traité comme une valeur vide ou non initialisée, c'est souvent source de confusion, c'est pourquoi il est important de documenter le comportement d'une méthode lorsqu'une valeur nulle est saisie. N'oubliez jamais que null est la valeur par défaut des variables de référence et que vous ne pouvez pas appeler de méthodes d'instance ni accéder aux variables d'instance à l'aide d'une référence null en Java.