Wie ist die Initialisierungsreihenfolge von Java-Klassen?

Initialisierungssequenz von Java-Klassen

Es ist sinnlos, mehr zu sagen. Das Folgende ist der Code, den ich persönlich getestet habe und der auf den ersten Blick klar ist:

 1 package test1;
 2 
 3 public class Test {
 4     public static void main(String[] argc) {
 5         new Child();
 6         System.out.println("================================");
 7         new Child();
 8     }
 9 }
10 
11 class Child extends Parent{
12     private static String staticField = getStaticField();
13     static {
14         System.out.println("child静态方法块初始化");
15     }
16     private String field = getField();
17     {
18         System.out.println("child普通方法块初始化");
19     }
20 
21     public Child() {
22         System.out.println("child构造函数初始化");
23     }
24 
25     public static String getStaticField() {
26         System.out.println("child静态属性初始化");
27         return "staticField";
28     }
29 
30     public static String getField() {
31         System.out.println("child普通属性初始化");
32         return "field";
33     }
34 }
35 
36 class Parent {
37     private static String staticField = getStaticField();
38     static {
39         System.out.println("parent静态方法块初始化");
40     }
41     private String field = getField();
42     {
43         System.out.println("parent普通方法块初始化");
44     }
45 
46     public Parent() {
47         System.out.println("parent构造函数初始化");
48     }
49 
50     public static String getStaticField() {
51         System.out.println("parent静态属性初始化");
52         return "staticField";
53     }
54 
55     public static String getField() {
56         System.out.println("parent普通属性初始化");
57         return "field";
58     }
59 }

Druckergebnis:

 1 parent静态属性初始化
 2 parent静态方法块初始化
 3 child静态属性初始化
 4 child静态方法块初始化
 5 parent普通属性初始化
 6 parent普通方法块初始化
 7 parent构造函数初始化
 8 child普通属性初始化
 9 child普通方法块初始化
10 child构造函数初始化
11 ================================
12 parent普通属性初始化
13 parent普通方法块初始化
14 parent构造函数初始化
15 child普通属性初始化
16 child普通方法块初始化
17 child构造函数初始化

Durch Ersetzen der Deklarationsreihenfolge von statischen Attributen und statischen Initialisierungsblöcken wird festgestellt, dass die Initialisierungsreihenfolge von statischen Attributen und statischen Initialisierungsblöcken mit der Deklarationsreihenfolge zusammenhängt Deklarationsanordnung.

Zusammenfassung:

1. Wenn eine Klasse die Bedingungen für die Initialisierung erfüllt (in einem zukünftigen Blog zusammengefasst), wird zuerst die übergeordnete Klasse initialisiert (vom obersten übergeordneten Klassenobjekt abwärts initialisiert) und dann werden die Unterklassen initialisiert

2. Initialisieren Sie beim Initialisieren dieser Klasse zuerst statische Eigenschaften und statische Initialisierungsblöcke (bezogen auf die Deklarationsreihenfolge) und initialisieren Sie abwärts vom übergeordneten Klassenobjekt

3. Wenn Sie ein Objekt über new erstellen, initialisieren Sie zunächst die gewöhnlichen Eigenschaften und gewöhnlichen Initialisierungsblöcke (bezogen auf die Deklarationsreihenfolge) und rufen Sie dann die Konstruktormethode auf, die ebenfalls abwärts von der übergeordneten Klasse Object

4. ausgeführt wird Statische Eigenschaften und statische Initialisierungsblöcke werden nur einmal initialisiert. Nach der Initialisierung der Klasse wird beim erneuten Erstellen eines Objekts nur der dritte Schritt wiederholt.

Als nächstes folgt ein Zitat aus Java-Programmierideen:

Innerhalb einer Klasse bestimmt die Reihenfolge der Variablendefinitionen die Reihenfolge der Initialisierung. Auch wenn Variablendefinitionen auf verschiedene Methodendefinitionen verteilt sind, werden sie dennoch initialisiert, bevor eine Methode (einschließlich des Konstruktors) aufgerufen wird.

Das obige ist der detaillierte Inhalt vonWie ist die Initialisierungsreihenfolge von Java-Klassen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!