亲宝软件园·资讯

展开

java static关键字执行顺序

nianyuw 人气:0

类的生命周期

静态变量的初始化有两种途径: (1)在静态变量的声明处进行初始化 (2)在静态代码块中进行初始化

使用:使用这个类;卸载:

接着我们来了解static关键字的作用和使用条件

static关键字

static关键字修饰的数据存储在我们的方法区中的静态常量池中,static可以修饰方法、变量和代码块

static修饰方法:指定不需要实例化就可以激活的一个方法。this关键字不能再static方法中使用静态方法中不能使用非静态方法非静态方法可以调用静态方法。

static修饰变量:指定变量被所有对象共享,即所有实例都可以使用该变量。变量属于这个类。

static修饰代码块:无论放在哪里,都是放在main方法运行的。通常用于初始化静态变量,静态代码块属于类。不可以省略,没加static认为是构造代码块

static关键字执行顺序

先记住几个准则;

我们来通过一个例子来验证以下上面的观点

InitializeDemo.java

package com.qcby.demo.staticDemo;

/**
 * @ClassName TRRest
 * @Description TODO
 * @Author heaboy@heaboy.com
 * @Version 1.0.0
 */
public class InitializeDemo {
    private static int k = 1;
    private static InitializeDemo t1 = new InitializeDemo("t1");
    private static InitializeDemo t2 = new InitializeDemo("t2");
    private static int i = print("i");
    private static int n = 99;

    {
        print("初始化块");
        j=100;
    }
    public InitializeDemo(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;

    }
    static {
        print("静态块");
        n=100;
    }
    private int j = print("j");
    public static int print(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
    public static void main(String[] args) {
        InitializeDemo test = new InitializeDemo("test");
    }
}

输出结果:

我们来逐个分析,

一开始调用main方法,main方法内实例化InitializeDemo的对象,在对象载入之前,一定要是类先被载入

所以我们先加载InitializeDemo类,加载类的同时,会加载静态变量和静态代码块,但是是按顺序执行,且只执行一次

先加载如下静态变量

private static int k = 1;

加载如下静态变量的时候,发现要去加载类,由于类以及加载了,所以会加载这个对象,这个对象加载前,会执行非静态代码块

private static InitializeDemo t1 = new InitializeDemo("t1");

此时也就是

1:初始化块 i=0 n=0

接着执行

private int j = print("j");

2:j i=1 n=1

接着执行构造方法,

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

    }

3:t1 i=2 n=2

t1的实例化执行结束,接着执行t2的实例化

private static InitializeDemo t2 = new InitializeDemo("t2");

结果和上述一致,按非静态代码块和非静态属性然后构造方法方法的顺序执行

4:初始化块 i=3 n=3

5:j i=4 n=4

6:t2 i=5 n=5

两个静态属性(实例化)执行完,执行如下代码

private static int i = print("i");

7:i i=6 n=6

接着执行下面的代码,此时n变成了99

private static int n = 99;

接着执行静态代码块

static {
        print("静态块");
        n=100;
    }

8:静态块 i=7 n=99

类加载完毕,执行test对象的载入,参考t1,t2的实例化,按非静态代码块和非静态属性然后构造方法方法的顺序执行

9:初始化块 i=8 n=100

10:j i=9 n=101

11:test i=10 n=102

继承中的static执行顺序

例子一:

package com.qcby.demo.oop;

public class Test3 extends Base {
    static {
        System.out.println("test static");
    }
    public Test3(){
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test3();
    }
}
class Base{
    static {
        System.out.println("Base static");
    }
    public Base(){
        System.out.println("Base constructor");
    }
}

执行Test3的构造方法,要先加载Test3的类加载,由于Test3继承于Base,所以他要先加载父类Base,

所以先Base static 后test static 在执行子类的构造方法的时候,要先执行父类的构造方法,如果是多级继承,会先执行最顶级父类的构造方法,然后依次执行各级个子类的构造方法。 所以先执行Base constructor后执行test constructor结果就如上图

例子二(重点)

package com.qcby.demo.oop;

public class MyTest {
    MyPerson person = new MyPerson("test");//这里可以理解为成员变量辅助,,要先把MyPerson先加载到jvm中
    static {
        System.out.println("test static");//1
    }

    public MyTest() {
        System.out.println("test constructor");//5
    }

    public static void main(String[] args) {//main方法在MyTest类中,使用mian方法先加载MyTest的静态方法,不调用其他,
        MyClass myClass =new MyClass();//对象创建的时候,会加载对应的成员变量
    }
}
class MyPerson {
    static {
        System.out.println("person static");//3
    }

    public MyPerson(String str) {
        System.out.println("person " + str);//4  6
    }
}
class MyClass extends MyTest {
    MyPerson person = new MyPerson("class");//这里可以理解为成员变量辅助,要先把MyPerson先加载到jvm中
    static {
        System.out.println("class static");//2
    }
    
    public MyClass() {
        //默认super()
        System.out.println("class constructor");//7
    }
}

1.先看main方法,main方法回先加载对应的类,此时MyTest类和其静态的变量,方法和代码块会随类的加载而开辟空间。static是属于类的。所以test static优先执行,且此时MyTest类的其他语句不执行。

2.mian方法中调用了MyClass myClass =new MyClass(),实例化了一个MyClass类的对象,这时候会初始化对象的成员变量和调用对象的构造函数,而MyClass类继承于MyTest类,在加载MyClass类前,会先调用MyTest类,但是MyTest类以及其静态的变量,方法和代码块已经加载(在类的生命周期只执行一次),所以返回到子类(MyClass类)的加载,这时候会调用MyClass类的静态的变量,方法和代码块。所以class static第二个执行。

3.MyClass类加载完后,应该接着调用MyClass类的构造方法,在调用子类的构造方法前,会默认调用父类的无参构造方法(super()省略),调用父类的无参构造方法,相当于实例化父类的对象,这时候会先初始化对象的成员变量,这里的MyPerson person = new MyPerson(“test”);就相当于成员变量(属于对象,在对象的实例化的时候才加载),于是会加载MyPerson类和其静态的变量,方法和代码块。所以person static第三个执行

4.加载完MyPerson类和其静态的变量,方法和代码块后,会调用MyPerson类和的有参构造方法,即person test第四个执行

5.MyPerson类和的有参构造方法执行结束,返回父类MyTest,父类调用构造方法,即test constructor第五个执行

6.父类MyTest构造方法执行结束,返回子类,子类再调用构造方法前,先初始化对象的成员变量MyPerson person = new MyPerson(“class”);,这时候会先先加载MyPerson 和其静态的变量,方法和代码块。由于上述类以及加载,所以直接执行其有参构造方法,即person class第六个执行

7.MyPerson类和的有参构造方法执行结束,返回子类MyClass,子类调用构造方法,即class constructor第七个执行

父类static代码块–>子类static代码块–>父类普通代码块(成员对象属性初始化)–>父类构造方法–>子类普通代码块(成员对象属性初始化–>子类构造方法

总结

类加载顺序的三个原则是

类加载顺序为(默认变量卸载代码块前)

父类静态变量->父类静态语句块->子类静态变量->子类静态语句块->父类普通成员变量->父类动态语句块->父类构造器->子类普通成员变量->子类动态语句块->子类构造器

加载全部内容

相关教程
猜你喜欢
用户评论