Java类加载机制（仅作记录）

Posted 2020-09-28

下面声明类看看测试结果：

 

[java] view plain copy

 

1. package com.shareniu;  
2.   
3.   
4. public class HelloA {  
5.     {  
6.         System.out.println("before class HelloA");  
7.     }  
8.     public HelloA() {  
9.     System.out.println("HelloA");  
10.     }  
11.       
12.     static{  
13.         System.out.println("static HelloA");  
14.     }  
15.     {  
16.         System.out.println("after class HelloA");  
17.     }  
18. }  
19. public class HelloB extends HelloA {  
20. private int i;  
21. public HelloB() {  
22. System.out.println("HelloB");  
23. }  
24. {  
25. System.out.println(i);  
26. System.out.println(" before class HelloB");  
27. }  
28. {  
29. System.out.println("after class HelloB");  
30. }  
31. static{  
32. System.out.println("static HelloB");  
33. }  
34. public static void main(String[] args) {  
35. new HelloB();  
36. System.out.println("shareniu");  
37. new HelloB();  
38. }  

 

输出的结果是什么呢？

 

[java] view plain copy

 

1. static HelloA  
2. static HelloB  
3. before class HelloA  
4. after class HelloA  
5. HelloA  
6. 0  
7.  before class HelloB  
8. after class HelloB  
9. HelloB  
10. shareniu  
11. before class HelloA  
12. after class HelloA  
13. HelloA  
14. 0  
15.  before class HelloB  
16. after class HelloB  
17. HelloB  

 

1.1.1. 总结

1.实例化类对象的时候，先实例化父类的静态方法，再实例化子类的静态方法，而且只会执行一次。

2.静态块的代码的优先级是最高的。

3.先初始化父类的代码块，再执行父类的构造方法。继续初始化自己的代码块，再执行自己的构造方法。

4.代码块是优先于构造方法执行的。这里就是类对象初始化的2次构造机制造成的。先执行代码块初始化所有的变量信息，构造方法执行的时候，如果有变量的赋值，就去再次初始化已经修改的值的内存。

5.永远都是先加载父类，在加载子类。先加载static的，在加载类对象的变量信息。

6.代码块{}的执行顺序，从上而下执行。