浅谈Java类中的变量初始化顺序
一、变量与构造器的初始化顺序
我们知道一个类中具有类变量、类方法和构造器(方法中的局部变量不讨论,他们是在方法调用时才被初始化),当我们初始化创建一个类对象时,其初始化的顺序为:先初始化类变量,再执行构造器方法。代码验证:
public class Demo01 {
public int a1 = 1;
public String a2 = "initiaied!";
public Demo01() {
System.out.println(a1);
System.out.println(a2);
System.out.println("构造器方法被执行");
}
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
}
}
运行结果:
1
initiaied!
构造器方法被执行
可以看出,当我们创建一个Demo01对象时,先初始化了变量a1和a2,然后执行构造器方法。
二、静态变量与非静态变量的初始化顺序
静态变量是属于类本身,无论创建多少个对象,静态变量都只有一份存储区域,因此他会在类首次被访问或者首次创建类对象时被初始化,而且有且只能初始化一次。而非静态变量是属于每个对象,他是在创建每个对象时都初始化一次。因此,静态变量要先于非静态进行初始化。例子:
public class Demo02 {
public Cup cup1 = new Cup(1);
public static Cup cup2 = new Cup(2);
public Demo02() {
System.out.println("Demo02构造器被执行!");
}
public static void main(String[] args) {
Demo02 demo02 = new Demo02();
Demo02 demo02_01 = new Demo02();
}
}
class Cup {
public Cup(int i) {
System.out.println("Cup->" + i);
}
}
运行结果:
Cup->2
Cup->1
Demo02构造器被执行!
Cup->1
Demo02构造器被执行
当程序要执行main方法时,会先加载Demo02类文件,在加载时就会先初始化静态变量cup2,因此控制台输出”cup->2″。类加载完后,开始执行main方法,创建demo02对象,这时就会初始化类中的非静态变量cup1,控制台输出”cup->1″,然后执行构造器方法。创建第二个对象时,只初始化cup1,cup2为静态变量只初始化一次。
三、静态代码块与非静态代码块
静态代码块本质上就是一段静态变量的代码,其初始化和静态变量没有区别:当类首次被访问或者首次创建该类对象时被初始化,并且只初始化一次。
非静态代码块就是一段非静态变量的代码,他和非静态变量的初始化没有区别。
public class Demo03 {
static Table table1;
Table table2;
static {
table1 = new Table(1);
}
{
table2 = new Table(2);
}
public Demo03() {
System.out.println("Demo03构造器被执行");
}
public static void main(String[] args) {
new Demo03();
}
}
class Table {
public Table(int i) {
System.out.println("Table->" + i);
}
}
运行结果:
Table->1
Table->2
Demo03构造器被执行
四、父类与子类的初始化顺序
没有父类就没有子类,因此无论是类加载还是创建实例对象,父类都优先于子类进行初始化。
public class Demo04 extends Insect {
private int k = fun("Demo04中的k被初始化");
private static int x2 = fun("Demo04中的x2被初始化");
public Demo04() {
System.out.println("k=" + k);
System.out.println("j=" + j);
}
public static void main(String[] args) {
Demo04 demo04 = new Demo04();
}
}
class Insect {
public int i = 9;
public int j;
public static int x1 = fun("Insect中的x1被初始化");
public Insect() {
System.out.println("i=" + i + ",j=" + j);
j = 39;
}
public static int fun(String s) {
System.out.println(s);
return 47;
}
}
运行结果:
Insect中的x1被初始化
Demo04中的x2被初始化
i=9,j=0
Demo04中的k被初始化
k=47
j=39
当执行main方法时,加载器开始加载Demo04类文件,在加载过程中,加载器会注意到他有一个父类Insect还没被加载,因此会先加载父类Insect文件。类加载过程中会完成静态变量的初始化(此时并不执行构造器方法,构造器方法只有在创建对象时调用),Insect类加载完成后,接着加载Demo04类,都加载完成后,就开始执行main方法中的代码,创建Demo04对象。
由于继承关系,因此先创建父类Insect的实例对象,因此父类中的变量初始化和构造器先被执行,然后在初始化子类Demo04中的非静态变量和执行构造器方法。
五、总结
最后放一段代码,把前面所说情况都放在一起。
public class Son extends Father {
int m = fun("Son中的m 被初始化");
public Son() {
System.out.println("m = " + m);
System.out.println("j = " + j);
}
public static int x3 = fun("Son中的x3 被初始化");
public static void main(String[] args) {
Son son = new Son();
}
}
class Father extends GrandFather {
public int k = fun("Father中的k被初始化");
public static int x2 = fun("Father中的x2被初始化");
public Father() {
System.out.println("k=" + k);
System.out.println("j=" + j);
}
}
class GrandFather {
public int i = 9;
public int j;
public static int x1 = fun("GrandFather中的x1被初始化");
public GrandFather() {
System.out.println("i=" + i + ",j=" + j);
j = 39;
}
public static int fun(String s) {
System.out.println(s);
return 47;
}
}
运行结果:
GrandFather中的x1被初始化
Father中的x2被初始化
Son中的x3 被初始化
i=9,j=0
Father中的k被初始化
k=47
j=39
Son中的m 被初始化
m = 47
j = 39