在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。例如：
class Tag {
Tag(
int marker) {
System.out.println(
"Tag(" + marker +
")");
}
}
class Card {
Tag t1 =
new Tag(1);
// 先初始化t1
Card() {
// Indicate we're in the constructor:
System.out.println(
"Card()");
t3 =
new Tag(33);
// Re-initialize t3
}
Tag t2 =
new Tag(2);
// 然后初始化t2
void f() {
System.out.println(
"f()");
}
Tag t3 =
new Tag(3);
// 接着初始化t3
}
public class OrderOfInitialization {
public static void main(String[] args) {
Card t =
new Card();
t.f();
// Shows that construction is done
}
}
它的输入结果如下：
"Tag(1)",
"Tag(2)",
"Tag(3)",
"Card()",
"Tag(33)",
"f()"
// 以下是人综合例子：
//总的原则:先静态后动态,先定义初始化,后构造函数初始化
/**
* 实例化Child对象时
* 先父类静态成员初始化,后子类静态成员初始化
* 然后是父类成员,父类构造函数,最后是子类
* 成员,子类构造函数
*/
class Parent {
private static int s = getS("父类静态成员");
private int num = getNum();
public Parent() {
System.out.println("父类构造函数");
}
private static int getS(String string) {
System.out.println(string);
return 47;
}
public int getNum() {
System.out.println("父类私有成员");
return num;
}
public static void setS(int s) {
Parent.s = s;
}
}
class Child extends Parent {
private int num = prt("子类私有成员");
private static int s = getS("子类静态成员");
public static void setS(int s) {
Child.s = s;
}
public Child() {
System.out.println("子类构造函数");
}
public void setNum(int num) {
this.num = num;
}
private int prt(String string) {
System.out.println(string);
return 5;
}
public static int getS(String string) {
System.out.println(string);
return s;
}
}
public class Tee {
/**
* @param args
*/
public static void main(String[] args) {
Child c = new Child();
c.setNum(100);
// 为什么输出的是0
System.out.print(c.getNum());
// Child cStatic = new Child();
// cStatic.setS(100);
// System.out.println(cStatic.getS("s"));
}
}
最后输出结果：
父类静态成员
子类静态成员
父类私有成员
父类构造函数
子类私有成员
子类构造函数
父类私有成员
0