Chaque langage de programmation, y compris Java, est limité à null. Il n'y a aucun programmeur qui n'a rencontré aucun problème dans le code lié à null. Les programmeurs sont principalement confrontés NullPointerException lorsqu'ils essaient d'effectuer certaines opérations avec des données nulles. NullPointerException est une classe disponible qui appartient au package java.lang.
Avant de comprendre les faits de null, il est nécessaire d'avoir une connaissance des variables Java. Si tu ne sais pas quoi Variable Java c'est à dire, passez par le lien suivant :
Chaque développeur doit connaître les faits suivants concernant null en Java :
Sensible aux majuscules et minuscules
En Java, nous ne pouvons pas écrire null sous la forme NULL ou 0 comme en programmation C car null est un littéral et les mots-clés sont sensibles à la casse en Java.
Prenons un exemple pour comprendre le comportement sensible à la casse de null.
NullExample1.java
// import classes and packages if any public class NullExample1 { // main() method start public static void main (String[] args) throws java.lang.Exception { // declare and initialize an object with NULL Object obj1 = NULL; // declare and initialize an object with null Object obj2 = null; // print both objects System.out.println('The value of obj1 is: '+obj1); System.out.println('The value of obj2 is: '+obj2); } } Sortir:
Valeur de la variable de référence
Par défaut, chaque variable de référence a une valeur nulle en Java. Une variable de référence est utilisée pour indiquer et stocker des objets/valeurs de type référence en Java. Les classes, tableaux, énumérations et interfaces, etc., sont des types de référence en Java.
Ainsi, un type référence stocke une valeur nulle si aucun objet n’est transmis à un type référence.
taille de la police latex
Prenons un exemple pour comprendre comment fonctionne une variable de référence pour une valeur nulle :
NullExample2.java
// import classes and packages if any public class NullExample2 { // declare two objects private static Object obj1; private static Object obj2; // main() method start public static void main (String[] args) { // print both objects System.out.println('The value of obj1 is: '+obj1); System.out.println('The value of obj2 is: '+obj2); } } Sortir:
Type nul
En Java, null n'est ni un objet ni un type. C'est une valeur spéciale que nous pouvons attribuer à n'importe quelle variable de type référence. Nous pouvons convertir null dans n'importe quel type dans lequel nous voulons, comme string, int, double, etc.
Prenons un exemple pour comprendre comment nous pouvons attribuer des valeurs nulles à n'importe quel type de référence.
NullExample3.java
// import classes and packages if any public class NullExample3 { // main() method start public static void main (String[] args) { // pass a null value to a different type of variable // pass null to String String str = null; // pass null to Integer Integer itr = null; // pass null to Double Double dbl = null; // casting null to String String castedStr = (String)null; // casting null to Integer Integer castedItr = (Integer)null; // casting null to Double Double castedDbl = (Double)null; // print all reference type System.out.println('The value of str is: '+str); System.out.println('The value of itr is: '+itr); System.out.println('The value of dbl is: '+dbl); System.out.println('The value of castedStr is: '+castedStr); System.out.println('The value of castedItr is: '+castedItr); System.out.println('The value of castedDbl is: '+castedDbl); } } Sortir:
Boîte automatique et déballage
Boîte automatique et Déballage sont les deux opérations les plus importantes que nous effectuons en Java. Le compilateur lance NullPointerException lorsque nous attribuons une valeur nulle à n’importe quel type de données primitif encadré lors de l’exécution des opérations.
Prenons un exemple pour comprendre l'autoboxing et le fait de null lors du déballage.
NullExample4.java
// import classes and packages if any public class NullExample4 { // main() method start public static void main (String[] args) throws java.lang.Exception { // pass null value to a reference type Integer itr = null; // perform unboxing operation int data = itr; // print both objects System.out.println('The value of itr is: '+itr); System.out.println('The value of data is: '+data); } } Sortir:
L'instance de l'opérateur
Afin de vérifier si un objet est une instance du type spécifié ou non, nous utilisons le exemple de opérateur. Le exemple de L’opérateur renvoie vrai lorsque la valeur de l’expression n’est pas nulle au moment de l’exécution. Il joue un rôle important dans les contrôles de transtypage.
Prenons un exemple pour comprendre exemple de opérateur:
hashset vs hashmap
NullExample5.java
// import classes and packages if any public class { // main() method start public static void main (String[] args) throws java.lang.Exception { // pass null value to a reference type Integer m = null; // pass a value to a reference type Integer n = 20; // print instanceof values System.out.println(m instanceof Integer); System.out.println(n instanceof Integer); } } Sortir:
Statique contre. Méthodes non statiques
Nous ne pouvons pas appeler une méthode non statique sur une variable de référence avec une valeur nulle. Si nous l'appelons, cela lancera NullPointerException, mais nous pouvons appeler la 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 lèveront pas d’exception de pointeur Null.
Prenons un exemple pour comprendre le fait de null :
NullExample6.java
// import classes and packages if any public class NullExample6 { // define static method public static void staticMethod() { //it can be called by using a null reference System.out.println('static method can be called by null reference.'); } // define non static method public void nonStaticMethod() { //it cannot be called by using a null reference System.out.println('static method cannot be called by a null reference.'); } // main() method start public static void main (String[] args) throws java.lang.Exception { NullExample6 exp = null; exp.staticMethod(); exp.nonStaticMethod(); } } Sortir:
== et != Opérateurs
En Java, ces deux opérateurs sont autorisés avec null. Les deux opérateurs sont utiles pour vérifier null avec des objets en Java.
Prenons un exemple pour comprendre comment ces deux opérateurs fonctionnent avec null.
comment afficher une application dans Android
NullExample7.java
// import classes and packages if any public class NullExample7 { // main() method start public static void main (String[] args) { // pass null value to String type of variables // pass null to str1 String str1 = null; // pass null to str2 String str2 = null; // pass null to str3 String str3 = 'Test'; // compare strings if(str1 == str2){ System.out.println('str1 and str2 both are equal'); }else{ System.out.println('str1 and str2 are not equal'); } if(str2 == str3){ System.out.println('str2 and str3 both are equal'); }else{ System.out.println('str2 and str3 are not equal'); } if(str3 == str1){ System.out.println('str3 and str1 both are equal'); }else{ System.out.println('str3 and str1 are not equal'); } } } Sortir:
Chaque développeur Java doit avoir connaissance de tous les faits nuls évoqués ci-dessus.