Java 中对类的主动引用和被动引用

最新推荐文章于 2022-07-14 21:55:08 发布
最新推荐文章于 2022-07-14 21:55:08 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： Java 面试与笔试

看了《深入Java虚拟机》一书中关于“类是否初始化？“ 这一问题的探讨后，觉得有必要亲手做下总结

在实际代码中， 有些类可能看上去时初始化了，但实际上并没有。

举个例子，

对于一个类Fruit， 声明一个fruit[] 数组，看上去是很多个Fruit对象被初始化了，其实一个都没有，下面就竟可能全面的讨论一下这个问题

 

检测方式

在类里加一个静态区域，如果类初始化，那么这段静态区域就会有输出

 

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

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

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

I. new 一个类的时候会发生初始化
[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class T{
	//when initialize the class T, then will come the output
	static{  
		System.out.println("Initialize class T");
	}
}

public class Test0 {
	public static void main(String[] args) {
		T t = new T();
	}
}


输出：

 

II.调用类中的静态成员，除了final字段，看下面这个例子，final被调用但是没有初始化类
[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class A{
	static final int count = 1;
	
	//When call the class , this part is the first to execute
	static{  
		System.out.println("Initialize class A");
	}
}

class Test1{
	public static void main(String[] args) {
		int x = A.count;
	}
}


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

 

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

 

[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class X{
	static void Output(){
		System.out.println("Output !");
	}
	
	//When call the class , this part is the first to execute
	static{  
		System.out.println("Initialize class X");
	}
}

public class Test1_3 {
	public static void main(String[] args) {
		X.Output();
	}
}

输出：


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

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

[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class B{
	static final int count = 1;
	
	//When call the class , this part is the first to execute
	static{  
		System.out.println("Initialize class B");
	}
}

public class Test2 {
	public static void main(String[] args) throws 
	ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class classB = Class.forName("test.class_life_cycle.initialize.B");
	}
}

 

输出：

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

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

[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class Cfather{
	static{
		System.out.println("Initialize class Cfather");
	}
}

class Cson extends Cfather{
	static{
		System.out.println("Initialize class Cson");
	}
}

public class Test3 {
	public static void main(String[] args) {
		Cson son = new Cson();
	}
}
 
输出：

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

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

 

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

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

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

[java] view plain copy
print ?
  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. }  
package test.class_life_cycle.initialize;

class Dfather{
	static int count = 1;
	static{
		System.out.println("Initialize class Dfather");
	}
}

class Dson extends Dfather{
	static{
		System.out.println("Initialize class Dson");
	}
}

public class Test4 {
	public static void main(String[] args) {
		int x = Dson.count;
	}
}

 

2  通过数组定义类引用类，不会触发此类的初始化
[java] view plain copy
print ?
  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>  
package test.class_life_cycle.initialize;

class E{
	static{
		System.out.println("Initialize class E");
	}
}

public class Test5 {
	public static void main(String[] args) {
		E[] e = new E[10];
	}
}
<span style="color:#111111;"></span>

但是没有输出

 
3  常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化
[java] view plain copy
print ?
  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. }  

 
package test.class_life_cycle.initialize;

class F{
	static final int count = 1;
	static{
		System.out.println("Initialize class F");
	}
}

public class Test6 {
	public static void main(String[] args) {
		int x = F.count;
	}
}


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

IT独白者
关注
专栏目录
Java中对类进行初始化（主动引用，被动引用）
LZAlgorithm的博客
03-29 783
一个类的整个生命周期包括：加载，验证，准备，解析，初始化，使用，卸载 这里主要介绍一下必须对类进行“初始化”的5种情况 1、遇到new，getstatic，putstatic，invokestatic这四条字节码指令时； 2、对类进行反射调用时，如果类没有进行过初始化，则需先触发其初始化； 3、当初始化一个类时，其父类还没初始化，则需先触发其父类初始化；（PS：当一个接口在初始化时，并不要...
java ftp 被动模式_ftp 主动模式与被动模式
weixin_30558657的博客
02-21 1127
ftp 主动模式与被动模式2018-09-15ftp的工作原理ftp要用到两个tcp连接即要使用两个端口一个是命令链路：用来传递命令一个是数据链路：用来上传下载数据连接ftp server时有active和passive两种模式通常使用主动模式可完成上传下载主动模式工作原理客户端使用命令链路主动告诉服务端：我打开了XX端口，你来连我吧被动模式工作原理跟主动模式相反，服务端告诉客户端：我打开了XX端...
Java中对类的主动引用和被动引用
ayaoxinchao2的博客
08-20 222
  在Java代码中，有些类看上去初始化了，但其实没有。例如定义一定长度某一类型的数组，看上去数组中所有的元素已经被初始化，实际上一个都没有。对于类的初始化，虚拟机规范严格规定了只有对该类进行主动引用时，才会触发。而除此之外的所有引用方式称之为对类的被动引用，不会触发类的初始化。虚拟机规范严格地规定了有且仅有四种情况是对类的主动引用，即必须立即对类进行初始化。四种情况如下：1.遇到new、g...
主动引用和被动引用
墨迹
01-05 350
Java初始化，有且只有5种场景，会导致初始化 1）遇到new,getstatic,putstatic,invokestatic 这四条字节码指令时。 2）使用java.lang.reflect包的方法对类进行反射调用时。 3）初始化子类，其父类还未初始化 4）虚拟机启动，指定主类 5）java.lang.invoke.MethodHandler 实例最后解析结果REF_getStat...
类的主动引用与被动引用
lm12032015的博客
03-08 116
1/子类引用父类的静态变量,不会使子类初始化. 2.数组只是在堆内存中开辟一块空间,并不会加载类模板. 3.引用静态常量不会触发此类初始化,链接阶段已经存入类常量池了
java类的主动引用和被动引用
fyzzz9的博客
07-05 500
本文参考《深入理解JAVA虚拟机》第2版，此书JDK版本为1.7。 主动引用 java类的初始化阶段，虚拟机规范严格规定了5种情况必须立即对类进行初始化。 遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，...
浅谈Java中对类的主动引用和被动引用
08-28
浅谈Java中对类的主动引用和被动引用 Java 中的类引用可以分为两种：主动引用和被动引用。理解这两种引用机制对于 Java 程序的正确执行和优化至关重要。 一、主动引用 主动引用是指在 Java 程序中明确地使用某个...
java 主动模式 port_ftp中主动模式(port)与被动模式(PASV)
weixin_34597791的博客
02-16 534
开场白处理防火墙和其他网络连接问题时最常见的一个难题是主动FTP与被动FTP的区别以及如何完美地支持它们。幸运地是，本文能够帮助你清除在防火墙环境中如何支持FTP这个问题上的一些混乱。本文也许不像题目声称的那样是一个权威解释，但我已经听到了很多好的反馈意见，也看到了本文在许多地方被引用，知道了很多人都认为它很有用。虽然我一直在找寻改进的方法，但如果你发现某个地方讲的不够清楚，需要更多的解释，请告诉...
Java中类与对象的生命周期
12-22
4. **使用**：类的使用包括主动引用和被动引用。主动引用会导致类实例的创建，而被动引用则不会。例如，创建类数组仅引用类而不实例化，引用类的常量也不会导致初始化。 5. **卸载**：类的卸载发生在所有条件满足时...
类的四种主动引用和三种被动引用
默默的笔记
10-06 2163
首先一个java文件从被加载到被卸载这个生命过程，总共要经历4个阶段： 加载-&amp;gt;链接（验证+准备+解析）-&amp;gt;初始化（使用前的准备）-&amp;gt;使用-&amp;gt;卸载。 其中加载（除了自定义加载）+链接的过程是完全由jvm负责的，什么时候要对类进行初始化工作（加载+链接在此之前已经完成了），jvm有严格的规定（四种情况）： 1.遇到new，getstatic，putstatic，invokes...
何时类加载------主动引用和被动引用
JinXYan的博客
03-14 606
概述 类初始化阶段是类加载过程的最后一步，前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与之外，其余动作完全由虚拟机主导和控制。 到了初始化阶段，才真正开始执行类中定义的Java程序代码（或者说是字节码）。初始化阶段是执行类构造器＜clinit＞（）方法的过程。 类加载的初始化阶段就是类构造器的初始化。所谓的类构造器就是将静态变量的初始化动作和静态块中的所有的内容合并起来。...
java自引用/类的递归调用问题
han_100896的博客
07-14 810
java的自引用问题
JAVA 主动调用与被动调用
不疯的疯子
12-31 715
public class Test {    static {        System.out.println("***");    }    public static final String a = "sss";   //final static double a = Math.random();}public class Test1 {    public static void m...
前端主动调用和被动调用！！
GOOD LUCK
03-06 441
主动调用 $.ajax({ url:basepath+'status/linkfe', type:'get', dataType:'json', data:objdata, async:'false', success:function(data){ console.log(data); $('#todayTotal').text(data.dl_label...
Java 回调机制解读
jcpp9527的博客
04-18 346
模块间调用在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种：（1）同步调用同步调用是最基本并且最简单的一种调用方式，类A的方法a()调用类B的方法b()，一直等待b()方法执行完毕，a()方法继续往下走。这种调用方式适用于方法b()执行时间不长的情况，因为b()方法执行时间一长或者直接阻塞的话，a()方法的余下代码是无法执行下去的，这样会造成整个流程的阻塞。（2）...
java类中的自身关联（引用传递）
勤奋的伟哥哥的博客
12-02 1050
package asrfasf; class Car{ private String name; private double price; private People people; //车属于一个人 public Car(){} public Car(String name,double price){ this.name=name; this.price=price...
类的主动引用跟类的被动引用
weixin_44552194的博客
06-25 202
类的主动引用（一定会发生初始化），类的被动引用（不会发生类的初始化），发生类的主动引用有五种情况分别是： new一个类的对象 调用类静态变量，和静态方法 对类进行反射调用 启动main方法所在的类 当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类 类的被动引用有三种情况分别是： 引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了） 通过数组...
类的主动使用和被动使用
CCC的博客
09-08 1096
JVM规范了以下6种主动使用类的场景： 1.通过new关键字会导致类的初始化：这种是大家经常采用的初始化一个类的方式，它肯定会导致类的加载并且最终初始化。 2.访问类的静态变量，包括读取和更新会导致类的初始化，这种情况的示例代码如下 public class Simple{ static{ System.out.println("I will be initiali...
深入理解Java虚拟机的类加载生命周期与主动引用
主动引用会触发初始化，被动引用则不会，如通过子类引用父类的静态变量，或者数组定义等。 6. **使用（Using）**：类加载后，当类首次被JVM使用时，即使没有触发初始化，也会执行使用阶段。这通常意味着至少有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值