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 souffrirjava.lang.NullPointerException
et 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 NullPointerException
est 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 nombreuxnull 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 exceptions
et minimiser les vérifications nulles.
-
Tout d’abord, null est un mot-clé en Java, tout comme
public
,static
oufinal
. 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.
-
Tout comme chaque primitive a une valeur par défaut, par exemple
int
0, 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
myObj
référence statique afin de pouvoir l'utiliser directement dans une méthodemain
, qui est une méthode statique et ne permet pas d'accéder aux variables non statiques. intérieurement. -
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
. -
null ne peut être affecté qu'à un type référence ; vous ne pouvez pas affecter null à une variable primitive telle que
int
,double
,float
ouboolean
. 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 exception
au moment de l'exécution. Cela est dû à l'autoboxing (autoboxing
) en Java, et nous en verrons plus dans la section suivante. -
Toute classe wrapper avec une valeur nulle sera levée
java.lang.NullPointerException
lorsque Javaunbox
la 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 pourint
, false pourboolean
etc., 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
HashMap
etInteger 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 conversionInteger
enint
, comme c'est le cas lorsque la méthode est appeléeput()
, mais il oublie que si le nombre n'a pas encore été compté, la méthodeget()
retourneraHashMap
null, et non zéro, car la valeur par défaut est Integer, c'est null, pas 0, et la boxe automatique sera lancéenull pointer exception
lors de la tentative de conversion d'un Integer en variableint
. -
L'opérateur
instanceof
renverra 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
instanceof
qui le rend utile pour tester les conversions de type. -
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 fichiersNullPointerException
. 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)
-
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. -
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, Javanull == null
renvoie 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
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.
GO TO FULL VERSION