1.父类静态代码块(静态变量或静态方法,按顺序来执行);
2.子类静态代码块(静态变量或静态方法,按顺序来执行);
3.父类非静态代码块;
4.父类构造函数;
5.子类非静态代码块;
6.子类构造函数;
这其实是去年校招时我遇到的一道阿里巴巴的笔试题(承认有点久远了-。-),嗯,如果我没记错的话,当时是作为Java方向的一道选做大题。当然题意没有这么直白,题目只要求你写出程序运行后所有System.out.println的输出结果,其中程序是题目给的,而各个System.out.println的执行顺序不同会导致最后程序输出的结果也不同。
具体的题目我肯定记不清,不过我们可以换个直接的问法,如果类A和类B中有静态变量,静态语句块,非静态变量,非静态语句块,构造函数,静态方法,非静态方法,同时类A继承类B,请问当实例化A时,类内部的加载顺序是什么?
当时我也是一头雾水,事后我就自己写了一个小Demo,这才知道了类内部的实际加载顺,测试代码如下:
Class B:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
public
class
B{
//静态变量
static
int
i=
1
;
//静态语句块
static
{
System.out.println(
"Class B1:static blocks"
+i);
}
//非静态变量
int
j=
1
;
//静态语句块
static
{
i++;
System.out.println(
"Class B2:static blocks"
+i);
}
//构造函数
public
B(){
i++;
j++;
System.out.println(
"constructor B: "
+
"i="
+i+
",j="
+j);
}
//非静态语句块
{
i++;
j++;
System.out.println(
"Class B:common blocks"
+
"i="
+i+
",j="
+j);
}
//非静态方法
public
void
bDisplay(){
i++;
System.out.println(
"Class B:static void bDisplay(): "
+
"i="
+i+
",j="
+j);
return
;
}
//静态方法
public
static
void
bTest(){
i++;
System.out.println(
"Class B:static void bTest(): "
+
"i="
+i);
return
;
}
}
|
Class A:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public
class
A
extends
B{
//静态变量
static
int
i=
1
;
//静态语句块
static
{
System.out.println(
"Class A1:static blocks"
+i);
}
//非静态变量
int
j=
1
;
//静态语句块
static
{
i++;
System.out.println(
"Class A2:static blocks"
+i);
}
//构造函数
public
A(){
super
();
i++;
j++;
System.out.println(
"constructor A: "
+
"i="
+i+
",j="
+j);
}
//非静态语句块
{
i++;
j++;
System.out.println(
"Class A:common blocks"
+
"i="
+i+
",j="
+j);
}
//非静态方法
public
void
aDisplay(){
i++;
System.out.println(
"Class A:static void aDisplay(): "
+
"i="
+i+
",j="
+j);
return
;
}
//静态方法
public
static
void
aTest(){
i++;
System.out.println(
"Class A:static void aTest(): "
+
"i="
+i);
return
;
}
}
|
Class ClassLoading :
1
2
3
4
5
6
7
|
public
class
ClassLoading {
public
static
void
main (String args[]) {
A a=
new
A();
a.aDisplay();
}
}
|
程序运行结果如图:
通过上述示图,我们可以比较清晰的看出java类的整个加载过程。
1.若要加载类A,则先加载执行其父类B(Object)的静态变量以及静态语句块(执行先后顺序按排列的先后顺序)。
2.然后再加载执行类A的静态变量以及静态语句块。(并且1、2步骤只会执行1次)
3.若需实例化类A,则先调用其父类B的构造函数,并且在调用其父类B的构造函数前,依次先调用父类B中的非静态变量及非静态语句块.最后再调用父类B中的构造函数初始化。
4.然后再依次调用类A中的非静态变量及非静态语句块.最后调用A中的构造函数初始化。( 并且3、4步骤可以重复执行)
5.而对于静态方法和非静态方法都是被动调用,即系统不会自动调用执行,所以用户没有调用时都不执行,主要区别在于静态方法可以直接用类名直接调用(实例化对象也可以),而非静态方法只能先实例化对象后才能调用。
OK,今天就总结到这里了,如果有地方说的不好或有错误的地方,欢迎大家指出,定当改正,谢谢。
===================================================
class SingleTon {
public static int count1;
public static int count2 = 0;
//结果集
// count1=1
// count2=1
private static SingleTon singleTon = new SingleTon();
// public static int count1;
// public static int count2 = 0;
//结果集
// count1=1
// count2=0
//顺序放的不同,导致的结果不同
private SingleTon() {
count1++;
count2++;
}
public static SingleTon getInstance() {
return singleTon;
}
}
public class Test {
public static void main(String[] args) {
SingleTon singleTon = SingleTon.getInstance();
System.out.println("count1=" + singleTon.count1);
System.out.println("count2=" + singleTon.count2);
}
}