1.静态（static）成员变量和静态代码块代码块

static修饰的成员都是类成员，会随着JVM加载类的时候加载而执行，而没有被static修饰的成员也被称为实例成员，需要创建对象才会随之加载到堆内存。所以静态的会优先非静态的。静态成员变量优先于静态代码块执行；

2.非静态代码块和非静态成员变量

非静态代码块和静态代码块都是在JVM加载类时且在构造方法执行之前执行，非静态代码块在类中都可以定义多个；非静态代码块是在类被实例化的时候执行。每被实例化一次，就会被执行一次；非静态成员变量优先于非静态代码块和构造方法执行；

3.构造方法

执行构造方法的时候，在执行方法体之前存在隐式三步：
1）构造方法体的第一行是this语句，则不会执行隐式三步，
2）构造方法体的第一行是super语句，则调用相应的父类的构造方法，
3）构造方法体的第一行既不是this语句也不是super语句，则隐式调用super()，即其父类的默认构造方法，这也是为什么一个父类通常要提供默认构造方法的原因；

代码示例：

package com.dhcc.demo.springbootymldemo02.test;

public class Teacher {
    private String name;
    private Integer age;

    public Teacher(String str) {
        System.out.println(str + "--成员变量Teacher初始化");
    }
}

package com.dhcc.demo.springbootymldemo02.test;
import java.sql.Timestamp;
public class Person {
    private static Teacher teacher = new Teacher("静态");
    private  Teacher teacherOne = new Teacher("非静态");
    private Integer no;
    private Integer age;
    private String name;
    static {
        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------父类的静态代码块执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
     {
        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------父类的非静态代码块执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    Person() {
         Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------父类的构造方法执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.dhcc.demo.springbootymldemo02.test;
import java.sql.Timestamp;
public class Student extends Person {
    private Integer sNo;
    private Integer classNO;
    static {
         Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------Student类的静态代码块执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    {
        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------Student类的非静态代码块执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public Student() {
        super();
        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
            System.out.println("------Student类的构造方法执行------" + timestamp);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.dhcc.demo.springbootymldemo02.test;
public class Test {
    public static void main(String[] args) {
        new Student();
    }
}

静态--成员变量Teacher初始化
------父类的静态代码块执行------2022-03-28 11:16:40.657
------Student类的静态代码块执行------2022-03-28 11:16:41.661
非静态--成员变量Teacher初始化
------父类的非静态代码块执行------2022-03-28 11:16:42.669
------父类的构造方法执行------2022-03-28 11:16:43.679
------Student类的非静态代码块执行------2022-03-28 11:16:44.682
------Student类的构造方法执行------2022-03-28 11:16:45.689

静态代码块和非静态代码块的描述

代码块的作用

在类或者对象执行代码块，初始化属性的时候，可以写逻辑。静态代码块，只能直接定义静态属性

代码块的执行顺序：由父及子，静态先行

静态代码块：是用来初始化类的信息，在类被加载的时候就会被执行，且只执行一次。执行优先级高于非静态的初始化块。

非静态代码块：是用来初始化类的实例信息，在创建对象的时候就会被执行，且每创建一个对象都会被执行一次。执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。

构造方法：是用来创建对象的。

一、同类中静态代码块，非静态代码块，构造方法的执行顺序

执行顺序：静态代码块>非静态代码块>构造方法

即：程序在执行时，首先执行静态代码块，且只执行一次。接下来再创建对象时（new），首先执行非静态代码块，再执行构造方法。

示例1：

代码：

package com.csu.marden;

public class Demo {
	static{
		System.out.println("static");
	}
	{
		System.out.println("no static");
	}
	Demo5(){
		System.out.println("constructor");
	}
	
	
	
	public static void main(String[] args) {
		
	}

}

执行结果：

分析：

上述Demo类包含静态代码块，非静态代码块和构造方法。但是该类中没有具体的执行，只完成了类的加载，即只有静态代码块在类加载的时候被执行，且只执行一次。由于没有对类的实例化，所有非静态代码块和构造方法均未执行。

示例2：

代码：

package com.csu.marden;

public class Demo5 {
	static{
		System.out.println("static");
	}
	{
		System.out.println("no static");
	}
	Demo5(){
		System.out.println("constructor");
	}
	
	
	
	public static void main(String[] args) {
		Demo demo=new Demo();
	}

}

执行结果：

分析：

上述Demo类包含静态代码块，非静态代码块和构造方法。上述代码首先完成了类加载，即静态代码块执行，且仅执行一次。然后创建了该类的实例，首先执行了非静态代码块，然后执行了构造方法。

示例3：

代码：

package com.csu.marden;

public class Demo5 {
	static{
		System.out.println("static");
	}
	{
		System.out.println("no static");
	}
	Demo5(){
		System.out.println("constructor");
	}
	
	
	
	public static void main(String[] args) {
		Demo demo1=new Demo();
		Demo demo2=new Demo();
	}

}

执行结果：

分析：

上述Demo类包含静态代码块，非静态代码块和构造方法。上述代码首先完成了类加载，即静态代码块执行，且仅执行一次。然后创建了该类的两个实例，首先执行了非静态代码块，然后执行了构造方法。并且非静态代码块和构造方法，在每次创建新的对象时，都会被执行一次。

二、父类和子类中静态代码块，非静态代码块，构造方法的执行顺序

在Java继承中，父类子类构造方法、静态代码块、非静态代码块的执行顺序：

父类静态代码块 > 子类静态代码块 > 父类非静态代码块 > 父类构造方法 > 子类非静态代码块 > 子类构造方法

示例1：

代码：

//父类
public class Parent {
    static String name = "hello";
    {
        System.out.println("parent-no-block");
    }
    static {
        System.out.println("parent-static");
    }

    public Parent() {
        System.out.println("parent-constructor");
    }
    
}



//子类
public class Child extends Parent {
    static String childName = "hello";
    {
        System.out.println("child-no-static");
    }
    static {
        System.out.println("child-static");
    }

    public Child() {
        System.out.println("child-constructor");
    }
}




//测试类
public class Demo {
	public static void main(String[] args) {
		new Child();
	}
}

执行结果：

分析：

Java继承体系中，若子类继承了父类，在创建子类的时候，首先会调用父类的构造方法和非静态代码块完成类实例的初始化，然后调用子类的构造方法和非静态代码块完成类实例的初始化（子类需要根据父类的构造方法生成）。

所以在执行时（创建子类对象时），首先加载父类，即执行父类的静态代码块，且只执行一次，然后加载子类，即执行子类的静态代码块，同样只执行一次。然后执行父类的非静态代码块和构造方法完成父类实例的初始化，最后执行子类的非静态代码块和构造方法完成子类实例的初始化。

示例2：

代码：

//父类
public class Parent {
    static String name = "hello";
    {
        System.out.println("parent-no-block");
    }
    static {
        System.out.println("parent-static");
    }

    public Parent() {
        System.out.println("parent-constructor");
    }
    
}



//子类
public class Child extends Parent {
    static String childName = "hello";
    {
        System.out.println("child-no-static");
    }
    static {
        System.out.println("child-static");
    }

    public Child() {
        System.out.println("child-constructor");
    }
}




//测试类
public class Demo {
	public static void main(String[] args) {
		new Child();
        new Child();
	}
}

执行结果：

分析：

在执行时（创建子类对象时），首先加载父类，即执行父类的静态代码块，且只执行一次，然后加载子类，即执行子类的静态代码块，同样只执行一次。然后执行父类的非静态代码块和构造方法完成父类实例的初始化，最后执行子类的非静态代码块和构造方法完成子类实例的初始化。由于本例中创建了两个子类对象，所以执行两次父类非静态代码块和构造函数，子类非静态代码块和构造函数。