Java 类主动引用和被动引用

主动引用（会发生初始化）

1 遇到new、getstatic、putstatic、invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。

生成这4条指令的几个最常见的Java代码场景是：

I. new 一个类的时候会发生初始化

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class T{  
4.     //when initialize the class T, then will come the output  
5.     static{    
6.         System.out.println("Initialize class T");  
7.     }  
8. }  
9.   
10. public class Test0 {  
11.     public static void main(String[] args) {  
12.         T t = new T();  
13.     }  
14. }  

输出：

 

II.调用类中的静态成员，除了final字段，看下面这个例子，final被调用但是没有初始化类

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class A{  
4.     static final int count = 1;  
5.       
6.     //When call the class , this part is the first to execute  
7.     static{    
8.         System.out.println("Initialize class A");  
9.     }  
10. }  
11.   
12. class Test1{  
13.     public static void main(String[] args) {  
14.         int x = A.count;  
15.     }  
16. }  

但是没有任何输出，就是因为 那个final字段，Java编译器把这样的字段解析成对常量的本地拷贝（该常量存在于引用者类，这里就是Test1类 的常量池里或者字节码里）

 

III. 调用某个类中的静态方法，那个类一定先被初始化了

 

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class X{  
4.     static void Output(){  
5.         System.out.println("Output !");  
6.     }  
7.       
8.     //When call the class , this part is the first to execute  
9.     static{    
10.         System.out.println("Initialize class X");  
11.     }  
12. }  
13.   
14. public class Test1_3 {  
15.     public static void main(String[] args) {  
16.         X.Output();  
17.     }  
18. }  

输出：

2  使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。

通过调用java.lang.Class.forName(String className) 

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class B{  
4.     static final int count = 1;  
5.       
6.     //When call the class , this part is the first to execute  
7.     static{    
8.         System.out.println("Initialize class B");  
9.     }  
10. }  
11.   
12. public class Test2 {  
13.     public static void main(String[] args) throws   
14.     ClassNotFoundException, InstantiationException, IllegalAccessException {  
15.         Class classB = Class.forName("test.class_life_cycle.initialize.B");  
16.     }  
17. }  

 

输出：

3  当初始化一个类的时候，如果发现其父类还没进行过初始化，则需要先触发其父类的初始化。

而且由下面的输出顺序可以看到先初始化父类，再是子类的

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class Cfather{  
4.     static{  
5.         System.out.println("Initialize class Cfather");  
6.     }  
7. }  
8.   
9. class Cson extends Cfather{  
10.     static{  
11.         System.out.println("Initialize class Cson");  
12.     }  
13. }  
14.   
15. public class Test3 {  
16.     public static void main(String[] args) {  
17.         Cson son = new Cson();  
18.     }  
19. }  

 

输出：

4  当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类。

其实就是public static void main（String[] args）所在的那个类

 

被动引用（看上去会，其实不会发生初始化）：

1  通过子类引用父类的静态字段，不会导致子类初始化

下面这个例子中，虽然是以Dson.count 形式调用的，但是因为count是Dfather的静态成员变量，所以只初始化Dfather类，而不初始化Dson类

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class Dfather{  
4.     static int count = 1;  
5.     static{  
6.         System.out.println("Initialize class Dfather");  
7.     }  
8. }  
9.   
10. class Dson extends Dfather{  
11.     static{  
12.         System.out.println("Initialize class Dson");  
13.     }  
14. }  
15.   
16. public class Test4 {  
17.     public static void main(String[] args) {  
18.         int x = Dson.count;  
19.     }  
20. }  

 

2  通过数组定义类引用类，不会触发此类的初始化

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class E{  
4.     static{  
5.         System.out.println("Initialize class E");  
6.     }  
7. }  
8.   
9. public class Test5 {  
10.     public static void main(String[] args) {  
11.         E[] e = new E[10];  
12.     }  
13. }  
14. <span style="color:#111111;"></span>  

但是没有输出

 

3  常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化

[java]  view plain  copy

1. package test.class_life_cycle.initialize;  
2.   
3. class F{  
4.     static final int count = 1;  
5.     static{  
6.         System.out.println("Initialize class F");  
7.     }  
8. }  
9.   
10. public class Test6 {  
11.     public static void main(String[] args) {  
12.         int x = F.count;  
13.     }  
14. }  

如上例中，F类中定义的count是final对象，其在编译阶段就会存入调用类的常量池中