一个类什么时候被加载
假设,有一个公共类A。另外两个B、C类的内部都使用了A类,并且都new出了对象。现在有另外一个D类,其内部new出了B、C两类的实例。试分析他们分别在什么时候被JVM加载?
图形表示如下:
(纠正一下,图中的“内存的数据产生”改为:类什么时候被加载,什么时候被实例化。)
第1步:公共类A:
public class ClassA {
/**
* 定义Class A
*/
//静态初始化块
static {
System.out.println("ClassA----我被加载了");
}
private static int age=20;
private String name="xiaowang";
public static int getAge() {
return age;
}
public String getName() {
return name;
}
}
第2步:B类(内部使用了A类)
public class ClassB {
/**
* 定义Class B
*/
static {
System.out.println("ClassB----我被加载了");
}
private ClassA classA;
public void myName() {
System.out.println("B方法---开始");
classA= new ClassA();
System.out.println("B方法---打印A的成员变量值:"+classA.getName());
System.out.println("B方法---结束");
}
}
第3步:C类(内部也使用了A类)
public class ClassC {
/**
* 定义Class B
*/
static {
System.out.println("ClassC----我被加载了");
}
private ClassA classA= new ClassA();
public void myName() {
System.out.println("C方法---开始");
System.out.println("C方法---打印A的成员变量值:"+classA.getName());
System.out.println("C方法---结束");
}
}
到这里,问一下大家:B、C两个类有什么不一样的地方?BinGo,成员变量classA实例化的地方不一样,B是在方法中new出对象,C是定义成员变量引用的时候就new对象了。(咋一看,感觉没什么不一样,都是实例化,但是这里面蕴含了JVM的一个思想,那就是–JVM运行程序时,是用到该类的对象,才会去加载该类到方法区。如果方法区已经加载过该类了,不会再去加载该类。)
注意一下:A、B、C 三个类都有一个静态初始化块,当一个类被加载的时候,块内的代码会得到执行。方便我们知道那个类被加载了。
第4步:D类(D类使用了B、C两个类)
public class DTest {
/**
* 定义Class D
*/
static {
System.out.println("ClassD----我被加载了");
}
//程序入口:
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassB classB = new ClassB();
ClassC classC = new ClassC();
classB.myName();
classC.myName();
}
}
好了,我们先来运行一下程序,打印一下结果:看看是怎么样的。
ClassD----我被加载了 ClassB----我被加载了 ClassC----我被加载了 ClassA----我被加载了 B方法---开始 B方法---打印A的成员变量值:xiaowang B方法---结束 C方法---开始 C方法---打印A的成员变量值:xiaowang C方法---结束
看不懂?没关系,下面我们一步步把D的程序来肢解。
1、如下代码,我们在程序入口里面,只实例化B类,并不执行B类实例的myName()方法。那么请问,ClassA会被加载吗?
public class DTest {
/**
* 定义Class D
*/
static {
System.out.println("ClassD----我被加载了");
}
//程序入口:
public static void main(String[] args) {
ClassB classB = new ClassB();
//注意:我们注释掉了,下面这个语句。
//classB.myName();
}
}
答案是:ClassA不会被加载。运行一下看看结果:
ClassD----我被加载了 ClassB----我被加载了
2、同样的情况,我们在程序入口里面,只实例化C类,那么请问,ClassA会不会被加载呢?
public class DTest {
/**
* 定义Class D
*/
static {
System.out.println("ClassD----我被加载了");
}
//程序入口:
public static void main(String[] args) {
ClassC classC = new ClassC();
}
}
我们运行一下看看结果:
ClassD----我被加载了
ClassC----我被加载了
ClassA----我被加载了
咦,为什么这次ClassA 会被加载了呢?对比一下,发现B、C两个类,在声明成员变量 classA的时候,B类中只是声明了一个引用变量–classA,并没给它赋值。只在方法被使用的时候,才new对象,而C类是声明后,直接new出对象赋值。所以A类会被加载。这也正好符合了java的特点,使用时,再加载。
强烈提示:java中的引用变量,其实就是一个地址指针,只是Java语言中没有指针这一说法罢了。以后一定要认为变量就是——地址指针。
3、那么如果D类只使用了B类,什么情况下,A类会被JVM 加载到方法区呢?我们来做下面这个实验。
public class DTest {
/**
* 定义Class D
*/
static {
System.out.println("ClassD----我被加载了");
}
//程序入口:
public static void main(String[] args) {
ClassB classB = new ClassB();
classB.myName();
}
}
运行一下,结果如下:
ClassD—-我被加载了
ClassB—-我被加载了
B方法—开始
ClassA—-我被加载了
B方法—打印A的成员变量值:xiaowang
B方法—结束
从结果中,可以看出,ClassA的加载,是在B的实例方法,被调用的时候,才去加载。
总结一下,本文的中心思想是讲了,一个类什么时候会被JVM加载。
有没有同学想过,JVM的类加载器,加载一个类的时候到底都干了些什么呢?这将是我们的下一个话题!