Java教程

浅谈Java类中的变量初始化顺序

本文主要是介绍浅谈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

 

这篇关于浅谈Java类中的变量初始化顺序的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!