Préface
En Java, un objet doit être correctement initialisé avant de pouvoir être utilisé, qui est stipulé par la spécification Java.
Initialisation automatique (par défaut)
Tous les membres de base de base d'une classe seront initialisés. Exécutez l'exemple suivant pour afficher ces valeurs par défaut:
class default {booléen t; Char C; octet b; shorts; int i; long l; flotter f; Double D; public void show () {System.out.println ("Valeur d'initialisation de base de base / N" + "Boolean <----->" + T + "/ N" + "Char <------>" + C + "/ N" + "BYTE <------>" + B + "/ N" + "Short <------>" + S + "/ N" + "Int <------>" + I + "/ N" + " l + "/ n" + "float <------>" + f + "/ n" + "double <----->" + d + "/ n"); }} public class initValue {public static void main (String [] args) {default d = new default (); D.Show (); }}【Résultats de l'opération】:
Valeur d'initialisation de type de base
booléen <-----> faux
char <----->
octet <-----> 0
court <-----> 0
int <-----> 0
long <-----> 0
float <-----> 0.0
Double <-----> 0,0
Où, la valeur par défaut du type de char est nul.
Pour les types de données non primitives, la poignée de l'objet est également initialisée:
classe de classe {nom de chaîne privée; // setter} class default {personne p; public void show () {System.out.println ("personne <---->" + p); }} public class initValue {public static void main (String [] args) {default d = new default (); D.Show (); }}【Résultats de l'opération】:
Personne <-----> null
On peut voir que la valeur d'initialisation de la poignée est nul. Cela signifie que si une méthode similaire à p.setName est appelée sans spécifier une valeur d'initialisation pour P, une exception se produira.
Règlement Initialisation
Si vous devez attribuer vous-même une valeur initiale à une variable, vous pouvez attribuer une valeur tout en définissant la variable.
class default {booléen t = true; char c = 'a'; octet b = 47; court s = 0xff; int i = 24; long l = 999; float f = 1,2f; Double D = 1,732; public void show () {System.out.println ("booléen <----->" + t + "/ n" + "char <------>" + c + "/ n" + "byte <------>" + b + "/ n" + "short <------>" + s + "/ n" + "int <----->" + i + "/ n" + "Long <----->" + "+" + "+" + n "+" "float <------>" + f + "/ n" + "double <------>" + d + "/ n"); }} public class initValue {public static void main (String [] args) {default d = new default (); D.Show (); }}Il peut même être initialisé d'une manière;
classe de classe {int i = set (); // ...}Ces méthodes peuvent également utiliser des variables indépendantes:
classe de classe {int i; int j = set (i); // ...} Initialisation du constructeur
L'avantage de l'initialisation d'un constructeur est que la valeur d'initialisation peut être déterminée pendant l'exécution. Par exemple:
Personne de classe {int Age; Personne () {âge = 89; }}L'âge sera d'abord initialisé à 0, puis deviendra 89. Cela est vrai pour tous les types de base ainsi que pour les poignées aux objets.
Ordre d'initialisation
Dans une classe, l'ordre d'initialisation est déterminé par l'ordre dans lequel les variables sont définies dans la classe. Même si les définitions de variables sont largement réparties au milieu de la définition de la méthode, la variable sera toujours initialisée avant d'appeler une méthode (y compris le constructeur). Par exemple:
classe Pet {Pet (int Age) {System.out.println ("Pet (" + Age + ")"); }} classe de classe {Pet t1 = new Pet (1); Personne () {System.out.println ("--- personne () ---"); t3 = nouvel animal de compagnie (33); } Pet T2 = nouveau PET (2); void show () {System.out.println ("show ----- Running"); } PET T3 = NOUVEAU PET (3);} Classe publique OrderOFinialization {public static void main (String [] args) {Person p = new Person (); p.show (); }}【Résultats de l'opération】:
Animal de compagnie (1)
Animal de compagnie (2)
Animal de compagnie (3)
--Personne()---
Animal de compagnie (33) <br/>
show ----- Courir
Dans l'exemple ci-dessus, bien que les définitions de T1, T2 et T3 soient partout dans la classe, l'ordre d'initialisation est déterminé par l'ordre de définition de T1, T2 et T3 (modifier T1, T2 et T3 par vous-même pour voir le résultat), et l'initialisation prévient l'exécution du générateur. Lorsque le constructeur est appelé, T3 est réinitialisé.
Initialisation des données statiques
Si les données sont statiques, le même processus sera effectué. S'il s'agit d'un type primitif et n'est pas initialisé, il obtiendra automatiquement sa propre valeur initiale de type primitif standard; S'il s'agit d'une poignée pour un objet, il obtiendra une valeur nulle à moins qu'un objet ne soit créé et connecté. S'il est initialisé au moment de la définition, la méthode prise est différente de la valeur non statique, car statique n'a qu'une seule zone de stockage. Par exemple:
class Bowl {bowl (int marqueur) {System.out.println ("bowl (" + marqueur + ")"); } void f (int marqueur) {System.out.println ("f (" + marqueur + ")"); }} table de classe {bol statique b1 = nouveau bol (1); Table () {System.out.println ("table ()"); b2.f (1); } void f2 (int marqueur) {System.out.println ("f2 (" + marqueur + ")"); } Bowl statique B2 = nouveau bol (2);} Classe Classe {Bowl B3 = nouveau bol (3); bol statique B4 = nouveau bol (4); Placard () {System.out.println ("Counboard ()"); B4.f (2); } void f3 (int marqueur) {System.out.println ("f3 (" + marqueur + ")"); } Bowl statique B5 = nouveau bol (5);} classe publique staticinitialisation {public static void main (String [] args) {System.out.println ("Création d'un nouveau placard () dans Main"); Nouveau armoire (); System.out.println ("Création d'un nouveau placard () dans Main"); Nouveau armoire (); t2.f2 (1); t3.f3 (1); } Tableau statique T2 = new Table (); Armoire statique T3 = nouveau placard ();}【Résultats de l'opération】:
Bol (1)
Bol (2)
Tableau()
F (1)
Bol (4)
Bol (5)
Bol (3)
Placard()
F (2)
Création d'un nouveau placard () en main
Bol (3)
Placard()
F (2)
Création d'un nouveau placard () en main
Bol (3)
Placard()
F (2)
F2 (1)
F3 (1)
Blocs de code statique
Java permet à d'autres travaux d'initialisation statique d'être divisés en un bloc de code spécial dans la classe. Ce bloc de code est sous la forme d'un mot-clé statique suivi d'un corps de méthode, appelé bloc de code statique. Un bloc de code statique n'est exécuté que lorsque l'objet de cette classe est généré pour la première fois ou que le membre statique appartenant à cette classe est accessible pour la première fois. Par exemple:
classe Person {Person (int Age) {System.out.println ("Person (" + Age + ")"); } void f (int age) {System.out.println ("f (" + age + ")"); }} classe Personnes {Personne statique P1; personne statique P2; statique {p1 = nouvelle personne (1); p2 = nouvelle personne (2); } Persons () {System.out.println ("Persons ()"); }} classe publique explicitStatic {public static void main (String [] args) {System.out.println ("inside main ()"); Persons.p1.f (18); // 1} Personnes statiques x = nouvelles personnes (); // 2 personnes statiques y = nouvelles personnes (); // 2}Lors de l'accès à l'objet statique P1 dans une ligne marquée 1, ou si la ligne 1 est commentée et que la ligne 2 n'est pas commentée, le module d'initialisation statique pour les personnes s'exécutera. Si 1 et 2 sont commentés, le bloc de code statique utilisé pour les personnes ne sera pas exécuté.
L'ordre des propriétés statiques et de l'exécution de blocs de code statique
classe Person {Person (int Age) {System.out.println ("Person (" + Age + ")"); }} Personnes de classe {Personne statique P = nouvelle personne (2); // 1 statique {p = nouvelle personne (3); } Personne statique p = nouvelle personne (2); // 2} classe publique Compstaticinit {public static void main (String [] args) {} Persons statiques x = nouvelles personnes ();}Selon l'analyse des résultats de l'annotation 1 conservant 2 et l'annotation 2 conservant 1, il peut être constaté que l'ordre d'exécution des propriétés statiques et des blocs de code statique dépend de l'ordre de codage. Celui qui est en tête sera exécuté en premier.
Initialisation des propriétés non statiques
Class Animal {Animal (int Age) {System.out.println ("Animal (" + Age + ")"); } void f (int age) {System.out.println ("f (" + age + ")"); }} classe publique notstaticinit {animal a1; Animal A2; {a1 = nouvel animal (1); a2 = nouvel animal (2); System.out.println ("A1 & A2 Initialisé"); } Notstaticinit () {System.out.println ("Notstaticinit"); } public static void main (String [] args) {System.out.println ("inside main ()"); NOTSTATICINIT X = new Notstaticinit (); }}Semblable aux blocs de code statique, l'ordre d'initialisation des blocs de code anonyme avec des propriétés non statiques dépend de l'ordre de codage .
Processus d'initialisation des objets héréditaire
classe insecte {int i = 1; Int J; Insect () {prt ("i =" + i + ", j =" + j); j = 2; } statique int x1 = prt ("statique insect.x1 initialisé"); static int prt (string s) {System.out.println (s); retour 3; }} Classe publique Beetle étend l'insecte {int k = prt ("beeklt.k initialisé"); Beetle () {prt ("k =" + k); prt ("j =" + j); } statique int x2 = prt ("statique bootle.x2 initialisé"); static int prt (string s) {System.out.println (s); retour 4; } public static void main (String [] args) {prt ("Constructeur de Beetle"); Beetle B = nouveau Beetle (); }}【Résultats de l'opération】:
insecte statique.x1 initialisé
statique bootle.x2 initialisé
Coléoptère
i = 1, j = 0
Beeklt.k initialisé
k = 4
j = 2
La première chose qui se produit lors de l'exécution de Java sur Beetle est le chargeur pour trouver cette classe à l'extérieur. Pendant le processus de chargement, le chargeur découvre une classe de base, il est donc chargé en conséquence. Ce processus sera effectué, que l'objet de la classe sous-jacent soit généré ou non. Si la classe de base contient une autre classe de base, l'autre classe de base sera chargée, etc. Ensuite, effectuez une initialisation statique dans la classe de base de racines, puis exécutez dans la classe dérivée suivante, et ainsi de suite. En effet, l'initialisation de la classe dérivée peut dépendre de l'initialisation des membres de la classe sous-jacents.
Lorsque toutes les classes sont chargées, les objets peuvent être créés. Tout d'abord, tous les types de données de base de cet objet sont définis sur leurs valeurs par défaut et la poignée de l'objet est définie sur NULL. Exécutez ensuite le constructeur de la classe de base. Cette situation est effectuée automatiquement ( super()， et le constructeur de la classe de base peut également être spécifié via Super). Une fois le constructeur de classe de base terminé, les variables d'instance de classe dérivées seront initialisées dans leur ordre d'origine et les parties du corps restantes du constructeur seront exécutées.
Résumez le processus de création d'objets:
L'exécution statique n'est effectuée que lorsque la classe est chargée et une seule fois;
Non statique ne s'exécute que lorsqu'il est instancié et exécute chaque fois qu'un objet est créé;
L'exécution statique est effectuée avant non-statique et la classe de base statique précède l'exécution statique sur les classes dérivées;
Les propriétés d'exécution des propriétés statiques et des blocs de code statique dépendent de leur position dans la classe et qui les exécute en premier;
L'ordre d'exécution des propriétés non statiques et des blocs de constructeur dépend de leur position dans la classe et qui s'exécute devant eux.
Résumer
Grâce à l'introduction ci-dessus, nous avons une compréhension de plusieurs façons d'initialiser les objets en Java et comment exécuter le code d'initialisation, et introduit également les situations que nous pouvons utiliser des variables non initialisées. Après avoir obtenu une compréhension détaillée de ces problèmes, vous pouvez éviter certains risques dans l'encodage pour vous assurer qu'un objet est complètement initialisé avant qu'il ne devienne visible.