Ordre d'initialisation variable statique
1. Règles simples
Tout d'abord, regardons le code Java le plus courant:
classe publique test {public static test1 t = new test1 (); public statique int a = 0; public statique Int B; public static void main (String [] arg) {System.out.println (test.a); System.out.println (test.b); }} classe test1 {public test1 () {test.a ++; Test.b ++; }}Voici une supposition quel est le résultat de sortie de la console?
OK, vous avez peut-être deviné le résultat ci-dessous, donc vous connaissez toujours Java.
Copiez le code comme suit: 0 1
Si vous ne comprenez pas pourquoi le résultat ci-dessus est la sortie, je vais vous le dire.
L'initialisation de la variable statique Java suit les règles suivantes:
Après avoir lu ceci, vous comprendrez que la valeur de Test.A a changé trois fois.
Réglé sur 0 lorsque déclaré >> test1 :: test1 est défini sur 1 >> test.a est initialisé à 0
2. Règles complexes
Si vous comprenez cela, veuillez consulter le code ci-dessous.
classe publique A {public static int b = ba; public statique a plus = new a ("a"); public static final int finalInt = (int) (math.random () * 100); public statique b p = new b ("a"); public statique final string finalStr = "finalstr"; Public statique final entier finalInteger = nouvel entier (10); public statique int a = 1; public statique b c = null; public a (String from) {System.out.println ("----------- commencez a :: a ----------------"); System.out.println ("A :: A, From =" + From); System.out.println ("A :: A, AB =" + AB); System.out.println ("A :: A, A.FinalInt =" + A.FinalInt); System.out.println ("a :: a, ba =" + ba); System.out.println ("A :: A, B.Plus =" + B.Plus); System.out.println ("----------- End A :: A ----------------"); } public static void main (String [] arg) {System.out.println ("main, ab =" + ab); System.out.println ("Main, bt =" + bt); System.out.println ("Main, Ca =" + CA); }} classe b {public static int t = aa; public statique a plus = new a ("b"); public statique int a = 1; public b (String from) {System.out.println ("----------- begin b :: b -----------------------"); System.out.println ("b :: b, de =" + from); System.out.println ("b :: b, ba =" + ba); System.out.println ("b :: b, aa =" + aa); System.out.println ("b :: b, ap =" + ap); System.out.println ("B :: B, a.plus =" + a.plus); System.out.println ("B :: B, a.finalInt =" + a.finalInt); System.out.println ("B :: B, a.finalInt =" + a.finalInt); System.out.println ("B :: B, a.finalInt =" + a.finalInt); System.out.println ("B :: B, a.finalInt =" + a.finalInt); System.out.println ("B :: B, a.finalInteger =" + A.FinalInteger); System.out.println ("b :: b, a.finalStr =" + a.finalStr); System.out.println ("----------- end B :: b ----------------"); }} classe C {public statique final a a = new a ("c");}Pouvez-vous encore deviner le résultat de sortie? Je l'ai écrit pendant les tests, donc je ne l'ai pas deviné. Haha
Le résultat de la sortie de la console est:
----------- commencez a :: a ---------------- A :: A, de = ba :: a, ab = 0a :: a, a.finalInt = 0a :: a, ba = 0a :: a, b.plus = null ----------- fin a :: a ----------------------- A.finalinT = 0a :: a, ba = 1a :: a, b.plus=a@a90653----------- fin a :: a --------------------------- commencez b :: b ---------------- b :: b, de = ab :: b, ba = 1b: b, b, aa = 0b :: b, ap = nullb :: b, a.plus A.finalInt = 61b :: b, a.finalInteger = nullb :: b, a.finalStr = finalstr ----------- fin b :: b ---------------- Main, ab = 1main, bt = 0 ----------- begin a :: a ---------------- a :: a, from = CA :: a, ab = 1a :: a, a.FinalIN B.plus=a@a90653---------- Fin A :: A -------------------- Main, CA = A @ 61DE33
Vous n'avez pas deviné ce résultat, haha.
Il faut beaucoup de temps pour expliquer les résultats d'exécution du programme un par un. Ici, nous noterons directement les règles suivie d'une initialisation de la variable statique Java.
Les règles du premier paragraphe sont toujours valables, mais elles ne sont pas saines.
Initialisation des données statiques
L'ajout de champs qualifiés statiques est le champ de classe soi-disant, ce qui signifie que le propriétaire de ce champ n'est pas un objet mais une classe. Peu importe le nombre d'objets créés, il n'y a qu'une seule copie des données statiques.
Le champ statique est toujours initialisé dans la classe, puis le champ général est initialisé. Puis initialisez le constructeur. Cependant, si un objet de cette classe n'est pas créé, l'objet ne sera pas initialisé et ne sera exécuté qu'une seule fois.
Comme dans le code suivant, dans la classe de staticitialisation, Table statique Table = new Table (); D'abord, puis l'objet de table ne sera pas initialisé, sinon il ne sera pas initialisé.
classe Bowl {bowl (int marqueur) {print ("bol (" + marqueur + ")"); } void f1 (int marqueur) {print ("f1 (" + marqueur + ")"); }} Tableau de classe {Bowl statique Bowl1 = nouveau bol (1); Table () {print ("table ()"); bol2.f1 (1); } void f2 (int marqueur) {print ("f2 (" + marqueur + ")"); } Bowl statique Bowl2 = nouveau bol (2);} Classe Classe {Bowl Bowl3 = nouveau bol (3); Bowl statique Bowl4 = nouveau bol (4); Placard () {print ("placard ()"); Bowl4.f1 (2); } void f3 (int marqueur) {print ("f3 (" + marqueur + ")"); } statique Bowl Bowl5 = nouveau bol (5);} classe publique staticinitialisation {public static void main (String [] args) {print ("Création d'un nouveau placard () dans main"); Nouveau armoire (); print ("Création d'un nouveau placard () dans Main"); Nouveau armoire (); table.f2 (1); placard.f3 (1); } table statique Table = new Table (); Armoire de placard statique = nouveau placard ();}Sortir:
Bol (1) bol (2) tableau () F1 (1) bol (4) bol (5) bol (3) placard () f1 (2) créant un nouveau placard () dans le placard Mainbowl (3) () F1 (2) créant un nouveau placard () dans le placard principal (3) armoire () F1 (2) F2 (1) F3 (1)
L'initialisation statique affichée (c'est-à-dire les blocs statiques)
Mettre plusieurs instructions d'initialisation dans une attelle statique est appelée un bloc statique. En fait, il est écrit ensemble en écrivant plusieurs statistiques, et l'essence est la même. Exécute uniquement lorsque l'objet est créé pour la première fois ou que le champ de la classe est accessible pour la première fois, et une seule fois.
Class Cup {Cup (int Marker) {print ("Cup (" + Marker + ")"); } void f (int marqueur) {print ("f (" + marqueur + ")"); }} Class Cups {Static Cup Cup1; Cup statique Cup2; statique {cup1 = nouveau tasse (1); Cup2 = nouvelle tasse (2); } Tass () {print ("tass ()"); }} classe publique explicitStatic {public static void main (String [] args) {print ("inside main ()"); Cups.cup1.f (99); // (1)} // tasses statiques tasses1 = nouvelles tasses (); // (2) // tasses statiques tasses2 = nouvelles tasses (); // (2)}Sortir:
À l'intérieur main () tasse (1) tasse (2) f (99)
Initialisation d'instance non statique
Il n'y a rien à dire à ce sujet, c'est juste une initialisation ordinaire, exécutée dans l'ordre, et peut être exécutée plusieurs fois.
classe Mug {Mug (int marqueur) {print ("Mug (" + Marker + ")"); } void f (int marqueur) {print ("f (" + marqueur + ")"); }} Mugs de classe publique {Mug Mug1; Mug Mug2; {Mug1 = nouvelle tasse (1); Mug2 = nouvelle tasse (2); print ("Mug1 & Mug2 initialisé"); } Mugs () {print ("Mugs ()"); } Mugs (int i) {print ("Mugs (int)"); } public static void main (string [] args) {print ("inside main ()"); Nouvelles tasses (); print ("New Mugs () terminé"); Nouvelles tasses (1); print ("Nouvelles tasses (1) terminées"); }}Inside main () tasse (1) Mug (2) Mug1 & Mug2 Initializedmugs () Nouvelles tasses () Complétedmug (1) Mug (2) Mug1 & Mug2 Initializedmugs (int) Nouvelles tasses (1) terminées