Pour les programmeurs Java, null est un casse-tête. Vous êtes souvent harcelé par les Null Pointer Exceptions (NPE). Même l'inventeur de Java a admis qu'il s'agissait d'une énorme erreur de sa part. Pourquoi Java garde-t-il null ? Le nul existe depuis un certain temps, et je pense que les inventeurs de Java savaient que le nul causait plus de problèmes que les problèmes qu'il résolvait, mais le nul est toujours avec Java.
Je suis de plus en plus surpris, car le principe de conception de Java est de simplifier les choses, c'est pourquoi on ne perd pas de temps en pointeurs, en surcharge d'opérateurs et en implémentation d'héritage multiple Null, c'est tout le contraire. Eh bien, je ne connais pas vraiment la réponse à cette question, ce que je sais, c'est que peu importe à quel point null est critiqué par les développeurs Java et la communauté open source, nous devons coexister avec null. Au lieu de regretter l’existence de null, nous devrions mieux en apprendre davantage sur null et nous assurer que null est utilisé correctement.
Pourquoi avez-vous besoin d’apprendre null en Java ? Parce que si vous ne faites pas attention à null, Java vous fera souffrir de NullPointerException et vous apprendrez une leçon douloureuse. La programmation énergétique est un art que votre équipe, vos clients et vos utilisateurs apprécieront davantage. D'après mon expérience, l'une des principales raisons des exceptions de pointeur nul est une connaissance insuffisante de null en Java. Beaucoup d'entre vous connaissent déjà null, mais pour ceux qui ne le connaissent pas, vous pouvez apprendre quelque chose d'ancien et de nouveau sur null. Réapprenons quelques connaissances importantes sur null en Java.
Qu’est-ce que Null en Java ?
Comme je l'ai dit, null est un concept très important en Java. L'intention initiale de null est de représenter quelque chose qui manque, comme un utilisateur, une ressource ou d'autres éléments manquants. Cependant, un an plus tard, l'exception gênante du pointeur nul a causé beaucoup de harcèlement aux programmeurs Java. Dans ce document, nous apprendrons les détails de base du mot-clé null en Java et explorerons quelques techniques pour minimiser les vérifications nulles et comment éviter les vilaines exceptions de pointeur nul.
1) Tout d’abord, null est un mot-clé en Java, comme public, static et final. Il est sensible à la casse, vous ne pouvez pas écrire null comme Null ou NULL, le compilateur ne les reconnaîtra pas et signalera une erreur.
Copiez le code comme suit :
Objet obj = NULL ; // Pas OK
Objet obj1 = null //Ok
Les programmeurs utilisant d'autres langages peuvent avoir ce problème, mais maintenant l'utilisation de l'IDE a rendu ce problème trivial. Désormais, lorsque vous tapez du code, les IDE comme Eclipse et Netbeans peuvent corriger cette erreur. Mais en utilisant d'autres outils comme le Bloc-notes, Vim et Emacs, ce problème vous fera perdre un temps précieux.
2) Tout comme chaque type primitif a une valeur par défaut, par exemple, la valeur par défaut de int est 0, la valeur par défaut de boolean est false et null est la valeur par défaut de tout type de référence. À strictement parler, c'est la valeur par défaut. de tous les types d'objets. Tout comme vous créez une variable booléenne dont la valeur par défaut est false, toute variable de référence en Java a null comme valeur par défaut. Cela est vrai pour toutes les variables, telles que les variables membres, les variables locales, les variables d'instance, les variables statiques (mais lorsque vous utilisez une variable locale non initialisée, le compilateur vous avertira). Pour démontrer ce fait, vous pouvez observer cette variable de référence en créant une variable puis en imprimant sa valeur, comme indiqué dans le code suivant :
Copiez le code comme suit :
Objet statique privé myObj ;
public static void main(String args[]){
System.out.println("Quelle est la valeur de monObjc : " + monObj);
}
Quelle est la valeur de myObjc : null
Cela est vrai pour les objets statiques et non statiques. Comme vous pouvez le voir ici, j'ai défini myObj comme référence statique afin de pouvoir l'utiliser directement dans la méthode principale. Notez que la méthode main est une méthode statique et ne peut pas utiliser de variables non statiques.
3) Nous voulons clarifier certains malentendus. Null n'est ni un objet ni un type. C'est juste une valeur spéciale. Vous pouvez également convertir null en n'importe quel type.
Copiez le code comme suit :
String str = null; // null peut être attribué à String
Integer itr = null; // vous pouvez également attribuer null à Integer
Double dbl = null; // null peut également être attribué à Double
String myStr = (String) null ; // null peut être converti en String
Integer myItr = (Integer) null; // il peut également être converti en Integer
Double myDbl = (Double) null; // oui c'est possible, pas d'erreur
Vous pouvez voir que la conversion de null vers n’importe quel type de référence est possible au moment de la compilation et de l’exécution, et ne lèvera pas d’exception de pointeur nul au moment de l’exécution.
4) Null peut être attribué aux variables de référence, mais vous ne pouvez pas attribuer null aux variables de type de base, telles que int, double, float et boolean. Si vous faites cela, le compilateur générera une erreur comme celle-ci :
Copiez le code comme suit :
int i = null; // incompatibilité de type : impossible de convertir de null en int
short s = null ; // incompatibilité de type : impossible de convertir de null en short
octet b = null : // incompatibilité de type : impossible de convertir de null en octet
double d = null ; //incompatibilité de type : impossible de convertir de null en double
Entier itr = null ; // c'est ok
int j = itr; // c'est également ok, mais NullPointerException au moment de l'exécution
Comme vous pouvez le voir, lorsque vous attribuez null directement à un type primitif, une erreur de compilation se produit. Mais si vous attribuez null à l'objet de classe wrapper, puis attribuez un objet aux types de base respectifs, le compilateur ne le signalera pas, mais vous rencontrerez une exception de pointeur nul au moment de l'exécution. Cela est dû au déballage automatique en Java, que nous verrons dans le prochain point.
5) Toute classe wrapper contenant une valeur nulle lèvera une exception de pointeur nul lorsque Java déballera et générera des types de données de base. Certains programmeurs font l'erreur de penser que l'autoboxing convertira null en la valeur par défaut du type de base respectif, comme 0 pour int et false pour le type booléen, mais ce n'est pas correct, comme indiqué ci-dessous :
Copiez le code comme suit :
Entier iAmNull = null ;
int i = iAmNull; // Rappelez-vous - Aucune erreur de compilation
Mais lorsque vous exécutez l'extrait de code ci-dessus, vous verrez sur la console que le thread principal lève une exception de pointeur nul. De nombreuses erreurs de ce type se produisent lors de l’utilisation des valeurs de clé HashMap et Integer. Une erreur apparaîtra lorsque vous exécuterez le code suivant.
Copiez le code comme suit :
importer java.util.HashMap ;
importer java.util.Map ;
/**
* Un exemple d'Autoboxing et NullPointerExcpetion
*
* @auteur WINDOWS 8
*/
Test de classe publique {
public static void main (String args []) lance InterruptedException {
Numéro de carteAndCount = new HashMap<>();
int[] nombres = {3, 5, 7,9, 11, 13, 17, 19, 2, 3, 5, 33, 12, 5} ;
pour(int i : nombres){
int count = numberAndCount.get(i);
numberAndCount.put(i, count++); // NullPointerException ici
}
}
}
Sortir:
Copiez le code comme suit :
Exception dans le thread "principal" java.lang.NullPointerException
à Test.main(Test.java:25)
Ce code semble très simple et sans erreur. Tout ce que vous avez à faire est de trouver combien de fois un nombre apparaît dans un tableau, ce qui est la technique typique pour rechercher des doublons dans les tableaux Java. Le développeur obtient d’abord la valeur précédente, puis en ajoute une et enfin remet la valeur dans la carte. Le programmeur peut penser qu'en appelant la méthode put, la boxe automatique gérera la boxe de int en Interger, mais il oublie que lorsqu'un nombre n'a pas de valeur de comptage, la méthode get() de HashMap renverra null, et Not 0 , car la valeur par défaut de Integer est null et non 0. Autoboxing renverra une NullPointerException lors du passage d'une valeur nulle à une variable int. Imaginez si ce code se trouvait dans un nid if et ne s'exécutait pas dans un environnement d'assurance qualité, mais une fois que vous l'avez placé dans un environnement de production, BOOM :-)
6) Si une variable de type référence avec une valeur nulle est utilisée, l'opération instanceof renverra false :
Copiez le code comme suit :
Entier iAmNull = null ;
si (instance iAmNull d'entier) {
System.out.println("iAmNull est une instance d'Integer");
}autre{
System.out.println("iAmNull n'est PAS une instance d'Integer");
}
Sortir:
Copiez le code comme suit :
je
AmNull n'est PAS une instance d'Integer
Il s'agit d'une fonctionnalité très importante de l'opération instanceof, la rendant utile pour les vérifications de conversion de type.
7) Vous savez peut-être que vous ne pouvez pas appeler une méthode non statique pour utiliser une variable de type référence avec une valeur nulle. Cela générera une exception de pointeur nul, mais vous ne savez peut-être pas que vous pouvez utiliser des méthodes statiques pour utiliser une variable de type référence avec une valeur nulle. Étant donné que les méthodes statiques utilisent une liaison statique, les exceptions de pointeur nul ne seront pas levées. Voici un exemple :
Copiez le code comme suit :
Test de classe publique {
public static void main(String args[]){
Test de monObjet = null ;
monObjet.iAmStaticMethod();
monObjet.iAmNonStaticMethod();
}
vide statique privé iAmStaticMethod(){
System.out.println("Je suis une méthode statique, peut être appelée par référence nulle");
}
vide privé iAmNonStaticMethod(){
System.out.println("Je suis une méthode NON statique, ne datez pas pour m'appeler par null");
}
Sortir:
Copiez le code comme suit :
Je suis une méthode statique, peut être appelée par référence nulle
Exception dans le thread "principal" java.lang.NullPointerException
sur Testing.main (Testing.java:11)
8) Vous pouvez transmettre null à la méthode et la méthode peut recevoir n'importe quel type de référence. Par exemple, public void print(Object obj) peut appeler print(null) comme ceci. C'est correct du point de vue de la compilation, mais le résultat dépend entièrement de la méthode. Les méthodes Null-safe, telles que la méthode print dans cet exemple, ne lèvent pas d'exception NullPointerException et se terminent simplement en douceur. Si la logique métier le permet, il est recommandé d’utiliser des méthodes null-safe.
9) Vous pouvez utiliser les opérations == ou != pour comparer des valeurs nulles, mais vous ne pouvez pas utiliser d'autres algorithmes ou opérations logiques, telles que inférieur ou supérieur à. Contrairement à SQL, null==null renverra true en Java, comme indiqué ci-dessous :
Copiez le code comme suit :
Test de classe publique {
public static void main (String args []) lance InterruptedException {
Chaîne abc = null ;
Chaîne cde = null ;
si(abc == cde){
System.out.println("null == null est vrai en Java");
}
si(null != null){
System.out.println("null != null est faux en Java");
}
// vérification nulle classique
si(abc==null){
// faire quelque chose
}
// pas ok, erreur de compilation
si(abc > nul){
}
}
}
Sortir:
Copiez le code comme suit :
null == null est vrai en Java
Tout est question de null en Java. Avec une certaine expérience en programmation Java et en utilisant des astuces simples pour éviter les exceptions de pointeur nul, vous pouvez rendre votre code null-safe. Étant donné que null est souvent utilisé comme valeur vide ou non initialisée, c'est une source de confusion. Pour les méthodes, il est également très important d’enregistrer le comportement de la méthode lorsque null est utilisé comme paramètre. Dans l’ensemble, rappelez-vous que null est la valeur par défaut de toute variable de type référence. Vous ne pouvez pas utiliser de références null pour appeler des méthodes d’instance ou des variables d’instance en Java.