源代码如下,求结果
public class MemoryAnalyse { public static int k = 0; public static MemoryAnalyse t1 = new MemoryAnalyse("t1"); public static MemoryAnalyse t2 = new MemoryAnalyse("t2"); public static int i = print("i"); public static int j = print("j"); public static int n = 99; { print("constructor code"); } static { print("static code"); } public static int print(String s) { System.out.println("i=" + i + " " + s + " k=" + k + " n=" + n + " j=" + j); ++i; ++k; ++n; return i; } public MemoryAnalyse(String string) { print(string); } public static void main(String[] args) throws ClassNotFoundException { MemoryAnalyse d = new MemoryAnalyse("T"); } }
然而结果是这个
i=0 constructor code k=0 n=0 j=0 i=1 t1 k=1 n=1 j=0 i=2 constructor code k=2 n=2 j=0 i=3 t2 k=3 n=3 j=0 i=4 i k=4 n=4 j=0 i=5 j k=5 n=5 j=0 i=6 static code k=6 n=99 j=6 i=7 constructor code k=7 n=100 j=6 i=8 T k=8 n=101 j=6
有没有很惊讶,结果竟然这么复杂.好,下面我们分析一下,在分析之前,先普及下不怎么用的基础知识
代码块和静态代码块何时运行问题:
代码块在创建对象时运行
静态代码块在类加载时运行
大家都知道static是属于类的并非对象,也就是说static修饰的东西都会在class加载到方法区时就存在在那里.所以方法区中类加载时内存过程如下
1.当类刚加载时会全部加载到方法区时,此时所有变量全部未实例化.
2.实例化参数t1
此时因为代码块在创建对象时执行,且在构造函数之前执行,所以先执行代码块
{ print("constructor code"); }
因为此时所有的变量都为默认值,所以执行后打印结果为
i=0 constructor code k=0 n=0 j=0
此时i,n,k的值都已经自加一,值为1
然后实例化调用构造函数
public MemoryAnalyse(String string) { //这里string为t1 print(string); }
构造函数调用结果如下
i=1 t1 k=1 n=1 j=0
此时i,n,k的值都已经自加一,值为2
3.实例化参数t2
和第一步一样在构造函数之前执行代码块
{
print("constructor code");
}
i=2 constructor code k=2 n=2 j=0
此时i,n,k的值都已经自加一,值为3
然后实例化调用构造函数
public MemoryAnalyse(String string) { //这里string为t2
print(string);
}
构造函数调用结果如下
i=3 t2 k=3 n=3 j=0
此时i,n,k的值都已经自加一,值为4
4.初始化参数i
这里直接调用print(“i”)函数,得到结果为
i=4 i k=4 n=4 j=0
此时i,k,j值为5,注意i的值不是通过自加一变成5的,而是通过函数的返回值赋给i的
5.初始化参数j
这里和上一步一样,执行print(“j”),然后把函数的返回值赋给j,打印结果为
i=5 j k=5 n=5 j=0
此时j的值已经为6
到这里类加载的内部参数变化就完成了,我们可以用加载类的方式调用一下
public static void main(String[] args) throws ClassNotFoundException { //MemoryAnalyse d = new MemoryAnalyse("T"); Class.forName("MemoryAnalyse"); }
Class.forName(类名字符串)是手动加载类到方法区,得到结果为
i=0 constructor code k=0 n=0 j=0
i=1 t1 k=1 n=1 j=0
i=2 constructor code k=2 n=2 j=0
i=3 t2 k=3 n=3 j=0
i=4 i k=4 n=4 j=0
i=5 j k=5 n=5 j=0
i=6 static code k=6 n=99 j=6 //这行的出现是因为static代码段在类加载时执行.n=99是因为类加载了,n的初值为99把之前的值覆盖掉了
然后改为我们之前的demo
public static void main(String[] args) throws ClassNotFoundException { MemoryAnalyse d = new MemoryAnalyse("T"); //Class.forName("MemoryAnalyse"); }
执行结果为
i=0 constructor code k=0 n=0 j=0 //t1代码块执行
i=1 t1 k=1 n=1 j=0 //t1构造函数执行
i=2 constructor code k=2 n=2 j=0 //t2代码块执行
i=3 t2 k=3 n=3 j=0 //t2构造函数执行
i=4 i k=4 n=4 j=0
i=5 j k=5 n=5 j=0
i=6 static code k=6 n=99 j=6 //静态代码块执行
i=7 constructor code k=7 n=100 j=6 //T代码块执行
i=8 T k=8 n=101 j=6 //T构造函数执行
最后两行的出现就很简单了,一个是代码块的,一个是构造函数的
这么一分析是不是简单了很多
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/17829.html