Java类的初始化顺序

 刚刚开始学习Java的时候就很想写这么一片文章，到今天没什么事，回顾一下以前学习的，弄出来当作记忆，废话不多说，程序猿应该直接上代码。。。

1.类无继承时的初始化顺序

 1 package com.cn.qiao.other.test;

 2 

 3 

 4 /**

 5  * @author yang_qiao

 6  * 类无继承时的初始化顺序

 7  * 静态变量、静态块、

 8  * 变量、普通块、

 9  * 构造器

10  *

11  */

12 public class ClassInitalOrderTest {

13     

14     //静态变量

15     public static String staticVar = "static variable";

16     //普通变量

17     private String normalVar = "normal variable";

18     

19     /**

20      * 在静态块中不能打印显示普通变量，

21      * 此时普通变量未被初始化，

22      * 如过打印显示直接提示错误

23      */

24     static{

25         System.out.println("Static block init");

26         System.out.println(staticVar);

27         //System.out.println(normalVar);

28     }

29     /**

30      * 静态块

31      */

32     {

33         System.out.println("Normal block init");

34         System.out.println(normalVar);

35     }

36     

37     /**

38      * 构造函数

39      */

40     public ClassInitalOrderTest(){

41         System.out.println("Constructor init");

42         System.out.println(staticVar);

43         System.out.println(normalVar);

44     }

45 

46     /**

47      * @param args

48      */

49     @SuppressWarnings("unused")

50     public static void main(String[] args) {

51         //测试

52         ClassInitalOrderTest ciot = new ClassInitalOrderTest();

53 

54     }

55 

56 }

2.有继承时子类的初始化顺序

 1 package com.cn.qiao.other.test;

 2 

 3 public class SuperClass {

 4     //父类静态变量

 5     public static String superStaticVar = "Super static variable";

 6     //父类普通变量

 7     private String superNormalVar = "Super normal variable";

 8     /**

 9      * 父类静态块

10      */

11     static{

12         System.out.println("Super static block init");

13         System.out.println(superStaticVar);

14         System.out.println("Super static block init over");

15     }

16     /**

17      * 父类普通块

18      */

19     {

20         System.out.println("Super normal block init");

21         System.out.println(superNormalVar);

22         System.out.println("Super normal block init over");

23     }

24     

25     /**

26      * 构造函数

27      */

28     public SuperClass(){

29         System.out.println("Super constructor init");

30         System.out.println(superStaticVar);

31         System.out.println(superNormalVar);

32         System.out.println("Super constructor init over");

33     }

34 

35 

36 }

 1 package com.cn.qiao.other.test;

 2 

 3 public class SubClass extends SuperClass {

 4     

 5     //子类静态变量

 6     public static String subStaticVar = "Sub static variable";

 7     //子类普通变量

 8     private String subNormalVar = "Sub normal variable";

 9     

10     /**

11      * 子类静态块

12      */

13     static{

14         System.out.println("Sub Class static block init");

15         System.out.println(subStaticVar);

16         System.out.println("Sub Class static block init over");

17     }

18     /**

19      * 子类普通块

20      */

21     {

22         System.out.println("Sub class normal block init");

23         System.out.println(subNormalVar);

24         System.out.println("Sub class normal block init over");

25     }

26     

27     /**

28      * 子类构造函数

29      */

30     public SubClass(){

31         System.out.println("Sub class constructor init");

32         System.out.println(subStaticVar);

33         System.out.println(subNormalVar);

34         System.out.println("Sub class constructor init over");

35     }

36 

37     /**

38      * @param args

39      */

40     @SuppressWarnings("unused")

41     public static void main(String[] args) {

42         //测试

43         /**

44          * 有继承时类的初始化顺序

45          * 父类-静态变量

46          * 父类-静态块

47          * 子类-静态变量

48          * 子类-静态块

49          * 父类-普通变量

50          * 父类-普通块

51          * 父类-构造函数

52          * 子类-普通变量

53          * 子类-普通块

54          * 子类-构造函数

55          */

56         SubClass sc = new SubClass();

57 

58     }

59 

60 }