java对象初始化顺序

java 对象是如何进行初始化的，新建一PrintClass.java文件如下（包括类PrintClass以及A和其子类B），编译运行其中的main方法，

 

 

 

 

Java代码

1. public class PrintClass {    
2.   
3.     public static void main(String[] args){    
4.   
5.         new B();    
6.   
7.     }    
8.   
9.     PrintClass(String var) {    
10.   
11.         System.out.println(var);    
12.   
13.     }    
14.   
15. }    
16.   
17.      
18.   
19. class A {    
20.   
21.     static PrintClass pClassA1 = new PrintClass("A. 静态成员的初始化1");    
22.   
23.     static {    
24.   
25.         System.out.println("A. 静态初始化块1");    
26.   
27.     }    
28.   
29.     static {    
30.   
31.         System.out.println("A. 静态初始化块2");    
32.   
33.     }    
34.   
35.     static PrintClass pClassA2 = new PrintClass("A. 静态成员的初始化2");    
36.   
37.      
38.   
39.     {    
40.   
41.         System.out.println("A. 实例初始化块1");    
42.   
43.     }    
44.   
45.     PrintClass pClassA = new PrintClass("A. 实例成员的初始化");    
46.   
47.     {    
48.   
49.         System.out.println("A. 实例初始化块2");    
50.   
51.     }    
52.   
53.      
54.   
55.     public int Avar;    
56.   
57.     public A() {    
58.   
59.         System.out.println("A. 构造方法");    
60.   
61.         doSomething();    
62.   
63.     }    
64.   
65.      
66.   
67.     private void doSomething() {    
68.   
69. //    public void doSomething() {    
70.   
71.         Avar = 1111;    
72.   
73.         System.out.println("Avar=" + Avar);    
74.   
75.     }    
76.   
77. }    
78.   
79.     

public class PrintClass { 

    public static void main(String[] args){ 

        new B(); 

    } 

    PrintClass(String var) { 

        System.out.println(var); 

    } 

} 

  

class A { 

    static PrintClass pClassA1 = new PrintClass("A. 静态成员的初始化1"); 

    static { 

        System.out.println("A. 静态初始化块1"); 

    } 

    static { 

        System.out.println("A. 静态初始化块2"); 

    } 

    static PrintClass pClassA2 = new PrintClass("A. 静态成员的初始化2"); 

  

    { 

        System.out.println("A. 实例初始化块1"); 

    } 

    PrintClass pClassA = new PrintClass("A. 实例成员的初始化"); 

    { 

        System.out.println("A. 实例初始化块2"); 

    } 

  

    public int Avar; 

    public A() { 

        System.out.println("A. 构造方法"); 

        doSomething(); 

    } 

  

    private void doSomething() { 

//    public void doSomething() { 

        Avar = 1111; 

        System.out.println("Avar=" + Avar); 

    } 

} 

  

 //class B extends A

 

 

Java代码

1. class B extends A    
2.   
3. {    
4.   
5.     public static void main(String[] args){    
6.   
7.         new B();    
8.   
9.     }    
10.   
11.     public int Bvar = 2222;    
12.   
13.      
14.   
15.     {    
16.   
17.         System.out.println("B. 实例初始化块1");    
18.   
19.     }    
20.   
21.     {    
22.   
23.         System.out.println("B. 实例初始化块2");    
24.   
25.     }    
26.   
27.     PrintClass pClassB = new PrintClass("B. 实例成员的初始化");    
28.   
29.      
30.   
31.     static {    
32.   
33.         System.out.println("B. 静态初始化块1");    
34.   
35.     }    
36.   
37.     static PrintClass pClassB1 = new PrintClass("B. 静态成员的初始化1");    
38.   
39.     static PrintClass pClassB2 = new PrintClass("B. 静态成员的初始化2");    
40.   
41.     static {    
42.   
43.         System.out.println("B. 静态初始化块2");    
44.   
45.     }    
46.   
47.      
48.   
49.     public B() {    
50.   
51.         System.out.println("B. 构造方法");    
52.   
53.         doSomething();    
54.   
55.     }    
56.   
57.     public void doSomething() {    
58.   
59.         System.out.println("Bvar=" + Bvar);    
60.   
61.     }    
62.   
63. }   

class B extends A 

{ 

    public static void main(String[] args){ 

        new B(); 

    } 

    public int Bvar = 2222; 

  

    { 

        System.out.println("B. 实例初始化块1"); 

    } 

    { 

        System.out.println("B. 实例初始化块2"); 

    } 

    PrintClass pClassB = new PrintClass("B. 实例成员的初始化"); 

  

    static { 

        System.out.println("B. 静态初始化块1"); 

    } 

    static PrintClass pClassB1 = new PrintClass("B. 静态成员的初始化1"); 

    static PrintClass pClassB2 = new PrintClass("B. 静态成员的初始化2"); 

    static { 

        System.out.println("B. 静态初始化块2"); 

    } 

  

    public B() { 

        System.out.println("B. 构造方法"); 

        doSomething(); 

    } 

    public void doSomething() { 

        System.out.println("Bvar=" + Bvar); 

    } 

} 

  

可以看到运行结果为：

A. 静态成员的初始化1

A. 静态初始化块1

A. 静态初始化块2

A. 静态成员的初始化2

B. 静态初始化块1

B. 静态成员的初始化1

B. 静态成员的初始化2

B. 静态初始化块2

A. 实例初始化块1

A. 实例成员的初始化

A. 实例初始化块2

A. 构造方法

Avar=1111

B. 实例初始化块1

B. 实例初始化块2

B. 实例成员的初始化

B. 构造方法

Bvar=2222

 

由此可知当新建一java对象（上面main方法中new B()）时，它的内部初始化顺序为：

1．  父类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行

2．  子类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行

3．  父类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行

4．  父类构造方法

5．  子类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行

6．  子类构造方法