首页 > 代码库 > JAVA的初始化顺序

JAVA的初始化顺序

2024-07-05 01:53:34   227人阅读

这里主要是介绍JAVA的类的初始化顺序，比较基础；主要是以例子演示为主：

  • 例子一：

 

 1 package com.cnblog.GDUTtiantian;
 2 
 3 /**
 4  * 
 5  * @author GDUTtiantian
 6  * @date 2014-5-19 下午1:30:10
 7  * JAVA类的初始化顺序
 8  */
 9 public class Tiantian {
10     
11     {
12         System.out.println("初始化：代码块1");
13     }
14     
15     {
16         System.out.println("初始化：代码块2");
17     }
18     
19     public Tiantian(){
20         
21         System.out.println("Constructor:Tiantian");
22     }
23     
24     {
25         System.out.println("初始化：代码块3");
26     }
27     
28     public static void main(String[] args) {
29         Tiantian client = new Tiantian();
30     }
31     
32 }
?
1
2
3
4
例子一运行结果：<br><br>初始化：代码块1
初始化：代码块2
初始化：代码块3
Constructor:Tiantian

　　

 

　　非静态代码块和普通变量一样，按照在程序出现的先后顺序，被加载到构造器中进行初始化；所以它们被初始化的顺序就是在程序中的出现的先后顺序。

　　下一步，稍微修改下例子一的代码：

  • 例子二：

 1 package com.cnblog.GDUTtiantian;
 2 
 3 /**
 4  * 
 5  * @author GDUTtiantian
 6  * @date 2014-5-19 下午1:30:10
 7  * JAVA类的初始化顺序
 8  */
 9 public class Tiantian {
10     
11     {
12         //这里编译不会出错，主要是当前代码块处于name属性的作用域范围。
13         this.name = "GDUT";
14         System.out.println("初始化：代码块1");
15     }
16     
17     {
18         System.out.println("初始化：代码块2");
19     }
20     
21     private String name = "tiantian";
22 
23     public Tiantian(){
24         
25         System.out.println("Constructor:Tiantian");
26     }
27     
28     {
29         System.out.println("初始化：代码块3");
30     }
31     
32     public static void main(String[] args) {
33         Tiantian client = new Tiantian();
34         System.out.println(client.name);
35     }
36     
37 }

　　

?
1
2
3
4
5
6
7
例子二运行结果：
 
初始化：代码块1
初始化：代码块3
初始化：代码块3
Constructor:Tiantian
tiantian

 

　　理解了这里，可以帮助更好地理解JAVA类的初始化过程。JAVA类不是在定义private String name = "tiantian";的时候先对name进行初始化，而是在代码块一中就对name进行了初始化，name的值为”GDUT”,然后再进一步初始化，name的值为”tiantian”.下面一个例子主要是针对具有继承关系的两个类的初始化顺序的探讨。

  • 例子三：

 1 package com.cnblog.GDUTtiantian;
 2 
 3 
 4 class Parent {//父类
 5     
 6     {//Parent:block 1
 7         this.name = "My parent.";
 8         System.out.println("Parent:代码块1");
 9     }
10     
11     private String name = "A Parent.";
12     
13     {//Parent:block 2
14         this.name = "Your parent.";
15         System.out.println("Parent:代码块2");
16     }
17     
18     
19     public Parent(){
20         System.out.println("Constructor:Parent");
21         System.out.println(this.name);
22     }
23     
24     {//Parent:block 3
25         this.name = "Their parent.";
26         System.out.println("Parent:代码块3");
27     }
28 }
29 
30 /**
31  * 
32  * @author GDUTtiantian
33  * @date 2014-5-19 下午1:30:10
34  * JAVA类的初始化顺序
35  */
36 public class Tiantian extends Parent{
37     
38     {//block 1
39         //这里编译不会出错，主要是当前代码块处于name属性的作用域范围。
40         this.name = "GDUT";
41         System.out.println("初始化：代码块1");
42     }
43     
44     {//block 2
45         System.out.println("初始化：代码块2");
46     }
47     
48     private String name = "tiantian";
49 
50     public Tiantian(){
51         
52         System.out.println("Constructor:Tiantian");
53     }
54     
55     {//block 3
56         System.out.println("初始化：代码块3");
57     }
58     
59     public static void main(String[] args) {
60         Tiantian client = new Tiantian();
61         System.out.println(client.name);
62     }
63     
64 }

　　　

?
1
2
3
4
5
6
7
8
9
10
11
12
例子三运行结果：
 
Parent:代码块1
Parent:代码块2
Parent:代码块3
Constructor:Parent
Their parent.
初始化：代码块1
初始化：代码块2
初始化：代码块3
Constructor:Tiantian
tiantian

　　

　　首先，初始化子类时，会先去调用父类的构造器（如果没有显示调用，则编译器会自动调用父类的无参构造器，如果此时父类没有无参构造器，则编译会出错。），如果父类有继承其他类，则会调用其他类的构造器；否则，和例子二的初始化顺序一样。

       总结：这里主要是涉及类的初始化，仅仅是非静态属性的初始化；还有其他的东西，后面会继续完善。

       以上是个人的观点，欢迎交流讨论。

 

 


联系
我们