Null en java

Null ne signifie rien, et le vide signifie vide. Vide est un type, tandis que Null est plus une valeur qu'un type dans son utilisation. En Java, null n'est pas échangé avec zéro. Cet article explique comment Null est utilisé dans Java.

Sensibilité à la casse

null est sensible à la casse. Il est nul, et non nul ou nul ou nul, etc.

Classe et objet instancié

Une classe est un ensemble de variables et de méthodes qui fonctionnent ensemble. Ces variables sont appelées champs (propriétés). Lorsque ces champs reçoivent des valeurs, l'unité résultante est appelée objet. Avoir un objet d'une classe est instanciant l'objet. Null peut être affecté à un objet, mais zéro ne peut pas être affecté. Le programme Java suivant se compile dans un code d'octets et s'exécute sans aucun message d'erreur:

classe CLA
int prop;
int mtthd ()
Retour Prop;


classe theclass
public static void main (String [] args)
CLA obj1 = new CLA ();
CLA obj2 = null;

La classe est la classe de la méthode principale (). La classe d'intérêt ici est CLA. Notez que Obj2 a pris null et non zéro dans la méthode principale ().

CLA obj2 = 0;

dans la méthode principale () aurait entraîné un message d'erreur.

Null et zéro nuance avec des types primitifs

Java a des types de données primitifs en usage normal et a des types de classe de données primitifs (wrapper). Par exemple, le code suivant est légitime en Java:

int i = 5;
Entier i = 5;
double d = 6.6;
Double d = 6.6;

I est la déclaration normale d'un type entier primitif, tandis que je suis la déclaration d'un objet de la classe entière. D est la déclaration normale d'un double type primitif, tandis que D est la déclaration d'un objet de la double classe.

Voici la nuance: je prends 0, tandis que je prends null dans le même but; D prend 0, tandis que D prend nul dans le même but. Le programme Java suivant se compile dans un code d'octets et s'exécute sans aucun message d'erreur:

classe theclass
public static void main (String [] args)
int i = 0;
Entier i = null;
double d = 0.0;
Double d = null;

Le code suivant entraînerait deux messages d'erreur par le compilateur:

int i = null;
Entier i = 0;
double d = null;
Double d = 0.0;

I et D peuvent prendre 0 ou null comme valeur, comme ils devraient. Cependant, I et D ne peuvent pas prendre NULL comme valeur, qui est la vraie nuance et la cause des deux messages d'erreur.

L'opérateur d'instance

L'opérateur instance OFF renvoie true si l'objet est l'instance (objet instancié) d'une classe particulière. La syntaxe est:

instance d'objet de classe

La sortie du programme suivant est vraie:

classe CLA
int prop;
int mtthd ()
Retour Prop;


classe theclass
public static void main (String [] args)
CLA obj = new CLA ();
Boolean BL = OBJ instance de CLA;
Système.dehors.println (BL);

Si Null a été affecté à OBJ comme suit:

CLA obj = null;

La sortie aurait été fausse.

Zéro n'est pas nul à Java

Le programme suivant ne se compile pas car zéro est de type int, tandis que Null est de type,:

classe theclass
public static void main (String [] args)
if (0 == null)
Système.dehors.println ("zéro peut être nul.");

Zéro ne peut pas être nul en java.

Types de types et de valeurs

Il existe deux types de types en Java: le type primitif et le type de référence. Les types primitifs sont booléens, int, double et leurs variantes. Ceux-ci ont leurs valeurs. Il existe quatre types de types de référence: types de classe, types d'interface, variables de type et types de tableau. Ceux-ci aussi ont leurs valeurs. Null est un type dont la seule valeur est nul. Le programme suivant illustre comment un type et une valeur INT primitifs peuvent être déclarés:

classe theclass
public static void main (String [] args)
int i = 5;
Système.dehors.println (i);

La sortie est 5. Le type nul ne peut pas être déclaré de la même manière. Null est normalement utilisé comme valeur et non dans la déclaration de type. C'est,

null i = null;

n'est pas possible.

Remarque: le nom d'un objet instancié est une référence.

Cours primitifs et null

Integer, en commençant par l'uppercase I, est la classe primitive du type int. Double, en commençant par la majuscule D, est la classe primitive du double type. Boolean, en commençant par l'uppercase B, est la classe primitive du type booléen. Ces types de classe prendraient null ou zéro, tandis que leurs types primitifs équivalents ne prendraient zéro que. Le programme suivant illustre ceci:

classe theclass
public static void main (String [] args)
Entier a = 0;
Entier b = null;
int c = 0;
Double d = 0.0;
Double e = null;
double f = 0;
Booléen g = false;
Booléen h = null;
booléen i = false;

Le programme se compile sans aucun problème. Remarque: Ni Boolean ni Boolean ne prennent 0 pour False.

null, imprimé comme nul

Tout aussi vrai et faux sont imprimés en mots, null est également imprimé comme un mot en java. Le programme suivant illustre ceci:

classe theclass
public static void main (String [] args)
Booléen a = false;
Booléen b = vrai;
Booléen c = null;
Système.dehors.println (a);
Système.dehors.println (b);
Système.dehors.println (c);

La sortie est:

FAUX
vrai
nul

null comme valeur de tableau

NULL peut être utilisé comme valeur dans un tableau si les valeurs sont de type de classe. Le programme suivant illustre ceci:

classe theclass
public static void main (String [] args)
String [] str = "un", null, "deux", null, "trois";
Système.dehors.println (str [0] + "+ str [1] +" + str [2] + "+ str [3] +" + str [4]);

La sortie est:

un null deux nuls trois

Notez que Null en tant qu'élément n'est pas entre guillemets. Ici, String est une classe. Il est importé par défaut. Il n'a pas à être importé manuellement.

L'ensemble du tableau est un objet. Donc null peut être affecté à un nom de tableau. Le programme suivant illustre ceci:

classe theclass
public static void main (String [] args)
String [] str = null;
Système.dehors.println (str);

La sortie est: nul.

Conclusion

Lorsque vous traitez avec des types primitifs, affectez zéro à la variable lorsque vous devez. Lorsque vous traitez avec des types de classes, vous pouvez attribuer zéro ou null en fonction du contexte. Ni Boolean ni Boolean ne prennent 0 pour False. En Java, Zero et Null ne sont pas interchangeables.