一文搞懂java中类及static关键字执行顺序

类的生命周期

• 加载：classpath、jar包、网络、某个磁盘位置下的类的class二进制字节流读进来，在内存中生成一个代表这个类的java.lang.Class对象放入元空间（方法区，永久代），此阶段我们程序员可以干预，我们可以自定义类加载器来实现类的加载；
• 验证：验证Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证虚拟机的安全；
• 准备：类变量赋默认初始值，int为0，long为0L，boolean为false，引用类型为null；常量赋正式值；
• 解析：把符号引用翻译为直接引用；
• 初始化：当我们new一个类的对象，访问一个类的静态属性，修改一个类的静态属性，调用一个类的静态方法，用反射API对一个类进行调用，初始化当前类，其父类也会被初始化… 那么这些都会触发类的初始化；

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

使用：使用这个类；卸载：

• 1.该类所有的实例都已经被GC，也就是JVM中不存在该Class的任何实例；
• 2.加载该类的ClassLoader已经被GC；
• 3.该类的java.lang.Class 对象没有在任何地方被引用，如不能在任何地方通过反射访问该类的方法；

接着我们来了解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代码块–>父类普通代码块（成员对象属性初始化）–>父类构造方法–>子类普通代码块（成员对象属性初始化–>子类构造方法

总结

类加载顺序的三个原则是

• 1、父类优先于子类
• 2、属性和代码块（看先后顺序）优先于构造方法
• 3、静态优先于非静态

类加载顺序为（默认变量卸载代码块前）

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

到此这篇关于一文搞懂java中类及static关键字执行顺序的文章就介绍到这了,更多相关java static关键字执行顺序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！