Statische variable Initialisierungsreihenfolge
1. Einfache Regeln
Schauen wir uns zunächst den häufigsten Java -Code an:
public class test {public static test1 T = neuer Test1 (); public static int a = 0; öffentliches statisches int b; public static void main (String [] arg) {System.out.println (test.a); System.out.println (test.b); }} class test1 {public test1 () {test.a ++; Test.b ++; }}Hier ist eine Vermutung, was das Ausgabeergebnis der Konsole ist?
Ok, vielleicht haben Sie das Ergebnis unten erraten, also sind Sie immer noch mit Java vertraut.
Kopieren Sie den Code wie folgt: 0 1
Wenn Sie nicht verstehen, warum das obige Ergebnis ausgegeben wird, werde ich es Ihnen sagen.
Die Initialisierung der statischen Variablen von Java folgt den folgenden Regeln:
Nachdem Sie dies gelesen haben, werden Sie verstehen, dass sich der Wert des Tests dreimal geändert hat.
Auf 0 einstellen, wenn deklariert >> test1 :: test1 auf 1 >> test eingestellt wird. Ein wird auf 0 initialisiert
2. Komplexe Regeln
Wenn Sie dies verstehen, schauen Sie sich bitte den Code unten an.
öffentliche Klasse A {public static int b = ba; public static a plus = neu a ("a"); public static final int finalInt = (int) (math.random ()*100); public static b p = neu b ("a"); public static Final String finalstr = "Finalstr"; öffentliche statische Final Integer Finalinteringer = New Integer (10); öffentliches statisches int a = 1; öffentliches statisches b c = null; public a (String von) {System.out.println ("----------- Beginnen a :: a ----------------"); System.out.println ("a :: a, von ="+von); 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 ("----------- Ende 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); }} Klasse B {public static int t = aa; public static a plus = new a ("b"); öffentliches statisches int a = 1; public b (String von) {System.out.println ("----------- Beginnen B :: B -----------------------"); System.out.println ("b :: b, von ="+von); 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. -finalsstr ="+A. -finalsstr); System.out.println ("----------- Ende b :: b ----------------"); }} Klasse C {public static final a a = new a ("c");}Können Sie das Ausgabeergebnis trotzdem erraten? Ich habe es beim Testen geschrieben, also habe ich es nicht erraten. Haha
Das Ergebnis der Konsolenausgabe ist:
----------- Beginnen Sie a :: a ------------------ A. finalint = 0a :: a, ba = 1a :: a, b.plus=a@a90653---------- enden a :: a -------------------------------- A. finalint = 61b :: b, A. finalInteger = nullb :: b, A.-finalsstr = finalstr ----------- Ende b :: b ---------------- Main, ab = 1Main, bt = 0 --------------- Beginnen a :: a -------------------- B.plus=A@a90653---------- Ende a :: a -------------------- Main, ca = a@61de33
Sie haben dieses Ergebnis nicht erraten, haha.
Es dauert viel Zeit, um die Ausführungsergebnisse des Programms einzeln zu erklären. Hier werden wir die Regeln direkt aufschreiben, gefolgt von der statischen Variablen -Initialisierung von Java.
Die Regeln im ersten Absatz sind immer noch gültig, aber nicht solide.
Initialisierung statischer Daten
Das Hinzufügen statisch qualifizierter Felder ist das sogenannte Klassenfeld, was bedeutet, dass der Eigentümer dieses Feldes kein Objekt, sondern eine Klasse ist. Unabhängig davon, wie viele Objekte erstellt werden, gibt es nur eine Kopie statischer Daten.
Das statische Feld wird immer in der Klasse initialisiert und dann wird das allgemeine Feld initialisiert. Dann initialisieren Sie den Konstruktor. Wenn jedoch nicht ein Objekt dieser Klasse erstellt wird, wird das Objekt nicht initialisiert und nur einmal ausgeführt.
Wie im folgenden Code in der staticInitialisierungsklasse statische Tabelle = new table (); Zuerst wird das Tabellenobjekt nicht initialisiert, sonst wird es nicht initialisiert.
Klasse Bowl {Bowl (int Marker) {print ("Bowl (" + marker + ")"); } void f1 (int marker) {print ("f1 (" + marker + ")"); }} Klassentabelle {static Bowl Bowl1 = New Bowl (1); Table () {print ("table ()"); Bowl2.f1 (1); } void f2 (int marker) {print ("f2 (" + marker + ")"); } static Bowl Bowl2 = neue Schüssel (2);} Klassenschrank {Bowl Bowl3 = neue Schüssel (3); statische Schüssel Schüssel 4 = neue Schüssel (4); Cupboard () {print ("cuppboard ()"); Bowl4.F1 (2); } void f3 (int marker) {print ("f3 (" + marker + ")"); } static Bowl Bowl5 = New Bowl (5);} öffentliche Klasse staticInitialisierung {public static void main (String [] args) {print ("neuer Schrank () in Main"); neuer Schrank (); print ("neuer Schrank () in Main"); neuer Schrank (); Tabelle.f2 (1); Schrank.F3 (1); } statische Tabelle Tabelle = new table (); statischer Schrankschrank = neuer Schrank ();}Ausgabe:
Schüssel (1) Schüssel (2) Tisch () F1 (1) Schüssel (4) Schüssel (5) Schüssel (3) Schrank () F1 (2) Erstellen neuer Schrank () in Mainbowl (3) Schrank () F1 (2) Erstellen neuer Schrank () in Mainbowl (3) Schrank () F1 (2) F2 (1) F3 (1)
Die angezeigte statische Initialisierung (dh statische Blöcke)
Das Einlegen mehrerer Initialisierungsanweisungen in eine statische Klammer wird als statischer Block bezeichnet. Tatsächlich wird es durch das Schreiben mehrerer Statik geschrieben, und die Essenz ist dasselbe. Ausleitet nur, wenn das Objekt zum ersten Mal erstellt wird oder das Feld der Klasse zum ersten Mal und nur einmal zugegriffen wird.
Klasse Cup {Cup (int Marker) {print ("cup (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} Klassenbecher {Static Cup Cup1; statischer Cup Cup2; static {Cup1 = neuer Tasse (1); Cup2 = neuer Tasse (2); } Cups () {print ("Cups ()"); }} public class explizitstatic {public static void main (String [] args) {print ("inside main ()"); Cups.cup1.f (99); // (1)} // statische Cups Cups1 = New Cups (); // (2) // statische Cups Cups2 = neue Cups (); // (2)}Ausgabe:
Inside Main () Tasse (1) Tasse (2) F (99)
Nichtstatische Instanzinitialisierung
Es gibt nichts zu sagen, es ist nur eine gewöhnliche Initialisierung, in der Reihenfolge ausgeführt und kann mehrmals ausgeführt werden.
Klasse Mug {Mug (int Marker) {print ("mugt (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} öffentliche Klasse Mugs {Mug Mug1; Mug Mug2; {Mug1 = neuer Becher (1); Mug2 = neuer Becher (2); print ("Mug1 & Mug2 initialisiert"); } Mugs () {print ("mugts ()"); } Mugs (int i) {print ("mugen (int)"); } public static void main (String [] args) {print ("inside main ()"); neue Tassen (); print ("neue Massen () abgeschlossen"); neue Tassen (1); print ("neue Becher (1) abgeschlossen"); }}Inside Main () Becher (1) Becher (2) Mug1 & Mug2 InitializedMugs () Neue Becher () fertige MUG (1) Becher (2) Mug1 & Mug2 InitializedMugs (int) neue Becher (1) abgeschlossen