java“块”的研究

本文重点关注静态块、非静态块、构造函数的加载顺序

直接上代码：

[java] view plaincopy

1. package test.staticblock;
2. public class A {
3. /*父类构造方法*/
4. public A(){
5. System.out.println("A constructor");
6. }
7. /*父类静态块*/
8. static
9. {
10. System.out.println("A static Block");
11. }
12. /*父类非静态块*/
13. {
14. System.out.println("A non-static Block");
15. }
16. /*父类静态方法*/
17. public static void printStaticMethod(){
18. System.out.println("A print Static Method");
19. }
20. /*父类普通方法*/
21. public void printNormalMethod(){
22. System.out.println("A print Normal Method");
23. }
24. }
25. class B extends A{
26. /*子类1构造方法*/
27. public B(){
28. System.out.println("B constructor");
29. }
30. /*子类1静态块*/
31. static{
32. System.out.println("B static Block");
33. }
34. /*子类1非静态块*/
35. {
36. System.out.println("B non-static Block");
37. }
38. /*子类1静态方法*/
39. public static void printStaticMethod(){
40. System.out.println("B print Static Method");
41. }
42. /*子类1普通方法*/
43. public void printNormalMethod(){
44. System.out.println("B print Normal Method");
45. }
46. }
47. class C extends A{
48. /*子类2构造方法*/
49. public C(){
50. System.out.println("C constructor");
51. }
52. /*子类2静态块*/
53. static{
54. System.out.println("C static Block");
55. }
56. /*子类2非静态块*/
57. {
58. System.out.println("C non-static Block");
59. }
60. /*子类2静态方法*/
61. public static void printStaticMethod(){
62. System.out.println("C print Static Method");
63. }
64. /*子类2没有override父类的普通方法*/
65. }

[java] view plaincopy

1. package test.staticblock;
2. public class Test {
3. public static void main(String[] args){
4. A a1 = new B();
5. A a2 = new C();
6. a1.printStaticMethod();
7. a1.printNormalMethod();
8. a2.printStaticMethod();
9. a2.printNormalMethod();
10. }
11. }

运行结果：

[plain] view plaincopy

1. A static Block
2. B static Block
3. A non-static Block
4. A constructor
5. B non-static Block
6. B constructor
7. C static Block
8. A non-static Block
9. A constructor
10. C non-static Block
11. C constructor
12. A print Static Method
13. B print Normal Method
14. A print Static Method
15. A print Normal Method

根据结果分析：

顺序应该是这样的:父类Static->子类static->父类缺省{}->父类构造函数->子类缺省{}->子类构造函数

分析:当执行new B()和new C()时，它首先去看父类里面有没有静态代码块，如果有，它先去执行父类里面静态代码块里面的内容，当父类的静态代码块里面的内容执行完毕之后，接着去执行子类(自己这个类)里面的静态代码块，当子类的静态代码块执行完毕之后，它接着又去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法，这个就是一个对象的初始化顺序。

总结:对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。

重要一点：

static 块仅在类加载时，并非实例化时，被执行一遍，且在整个过程中只可能被执行一遍，这也就是在实例化C时

A a2 = new C();

A的static块没有被执行的原因。

但非静态块在实例化对象时总会被执行。

静态块一般用于初始化类中的静态成员；而非静态块一般用于初始化类中的非静态成员；

另外，非静态块是在创建对象时自动执行的代码。