阿里地区笔试题 关于类的静态加载顺序 求高人解答

阿里笔试题 关于类的静态加载顺序 求高人解答
要求写出程序输出内容：

public class StaticTest {

public static int k = 0;
public static StaticTest t1 = new StaticTest("t1");
public static StaticTest t2 = new StaticTest("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");

{
print("构造快");
}

{
print("静态块");
}

public StaticTest(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}

public static int print(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++i;
return ++n;
}
public static void main(String[] args) {
StaticTest t = new StaticTest("init");
}

}

jdk1.6下测试输出的内容如下：

1:j i=0 n=0
2:构造快 i=1 n=1
3:静态块 i=2 n=2
4:t1 i=3 n=3
5:j i=4 n=4
6:构造快 i=5 n=5
7:静态块 i=6 n=6
8:t2 i=7 n=7
9:i i=8 n=8
10:j i=9 n=99
11:构造快 i=10 n=100
12:静态块 i=11 n=101
13:init i=12 n=102

我一开始还没觉得复杂，后来越想月复杂，越想月糊涂，求指点 阿里 java 静态类
[解决办法]
本来我是搞清楚的，又搞乱了，这贴顶上去
[解决办法]
看到两道java题，当时就虚了，一道都不会做。。怎么破！
[解决办法]
基本功不够扎实 这题肯定栽
[解决办法]
首先我承认，第一遍做的时候我也做错了。
后来自己就加了多个断点不断的调试以及设计了多个实验。算是了解了一些吧。
同时也算是谢谢楼主了，这算是帮我学习了。
首先加载的顺序为：
先父类的static成员变量-》子类的static成员变量-》父类的成员变量-》父类构造-》子类成员变量-》子类构造
也就是说最先被加载的是所有static申明的成员变量，之所以被申明为静态，特点就是共享，即使实例化多个对象，但是是共用一个static声明的变量的。
也就是说，首先所有的static被载入，但是还未执行，下一步开始执行，自上而下，首先执行完第一行之后执行public static StaticTest t1 = new StaticTest("t1"); 
实例化这个对象的时候，由于静态的已经被载入，所以就直接执行
public int j = print("j"); 这一句，然后执行
{         print("构造快");     }           {         print("静态块");     } 
最后执行构造函数，
然后实例化t2,
最后实例化对象。

做几个例子测试出该效果，推出什么原理大家自己理解吧。
第一个，public static StaticTest t1 = new StaticTest("t1");改为
public StaticTest t1 = new StaticTest("t1");  
结果：加载出错
第二个，把public int j = print("j");也改为静态的。

如果说的不对，请大家指出。谢谢
[解决办法]
果然我基础不行。我只能写出前两步。后面不知道怎么运行了。
[解决办法]
我觉得这道题目的静态块，是不是应该这样

static {
    print("静态块");
}

因为，这样考点就基本全了~~~
[解决办法]
类加载顺序：
 * 1.加载类的静态属性(非静态不管)
 * 这里加载的是:public static int k = 0;
 * 然后加载:public static StaticTest t1 = new StaticTest("t1");
 * 因为此处进行了类的实例化所以
 * 1.1加载类的非静态属性
 * 这里是:public int j = print("j");
 * 运行完这个方法接着
 * 1.2顺序加载类中的非static代码块(static暂时不加载)
 * 这里是:print("构造快");和print("静态块");
 * 运行完接着
 * 1.3加载类的构造方法
 * 这里是:public StaticTest(String str)
 * 运行完（一个静态属性的实例就完成了）
 * 2.继续加载类的静态属性
 * 这里加载的是:public static StaticTest t2 = new StaticTest("t2");
 * 2.1重复（1.1-1.3）
 * 3.继续加载类的静态属性
 * 这里加载的是:public static int i = print("i");
 * 运行完接着
 * 4.继续加载类的静态属性
 * 这里加载的是:public static int n = 99;
 * 不管你n原来是多少现在为99
 * 接着
 * 5.（如果有static代码块，在这里先加载，这个里面没有所以加载主函数）加载主函数
 * 这里加载的是:StaticTest t = new StaticTest("init");
 * 因为此处进行了类的实例化所以
 * 5.1
 * 重复1.1-1.3
 * 5.2
 * 因为public static int print(String str)这个方法返回++n
 * 所以n从99开始累加
 * 运行完OK了
------解决方案--------------------

那不是非静态代码块吗？
[解决办法]
楼主 一步一步来就能出来 这段代码就是乱的很 理清思路就行了
[解决办法]
感谢楼主的问题，让自己又巩固了一下知识！

安顺序之行代码！当程序执行到创建静态对象t1的时候，创建一个t1对象！创建t1对象时之行public int j,不会之行public static int i,因为静态变量属于类，不属于对象！
[解决办法]
我第一次也没弄出来  关键是这个题 太混乱了 ！！！
[解决办法]
估计LZ没仔细看过think in java，上面的例子比这个更复杂

[解决办法]
 静态块与静态成员是谁排在前面谁先加载，之前一直认为最先加载的是静态块里面的了
[解决办法]
学习了
[解决办法]

引用:

首先我承认，第一遍做的时候我也做错了。
后来自己就加了多个断点不断的调试以及设计了多个实验。算是了解了一些吧。
同时也算是谢谢楼主了，这算是帮我学习了。
首先加载的顺序为：
先父类的static成员变量-》子类的static成员变量-》父类的成员变量-》父类构造-》子类成员变量-》子类构造
也就是说最先被加载的是所有static申明的成员变量，之所以被申明为静态，特点就是共享，即使实例化多个对象，但是是共用一个static声明的变量的。
也就是说，首先所有的static被载入，但是还未执行，下一步开始执行，自上而下，首先执行完第一行之后执行public static StaticTest t1 = new StaticTest("t1"); 
实例化这个对象的时候，由于静态的已经被载入，所以就直接执行
public int j = print("j"); 这一句，然后执行
{         print("构造快");     }           {         print("静态块");     } 
最后执行构造函数，
然后实例化t2,
最后实例化对象。

做几个例子测试出该效果，推出什么原理大家自己理解吧。
第一个，public static StaticTest t1 = new StaticTest("t1");改为
public StaticTest t1 = new StaticTest("t1");  
结果：加载出错
第二个，把public int j = print("j");也改为静态的。

如果说的不对，请大家指出。谢谢

我有个疑问.
static被载入时，int值应该为空吧.
运行到创建t1的实例时，还没有运行static i的初始化代码吧？ 
为什么创建t1实例的时候，可以直接做i++?
[解决办法]
请看http://blog.csdn.net/hyl713/article/details/11925071

查看更多 下一篇