Talk about the initialization sequence of Java variables in detail

Rule 1 (without inheritance) :
For static variables, static initializer blocks, variables, initializer blocks, constructors, the initialization order is
(static variables, static initialization block) > (variable, initialization block) > The constructor
Proof code:

public class InitialOrderTest {
    //A static variable
    public static String staticField = " A static variable ";
    //variable
    public String field = " variable ";
    //Static initialization block
    static {
        System.out.println(staticField);
        System.out.println(" Static initialization block ");
    }
    //The initialization block
    {
        System.out.println(field);
        System.out.println(" The initialization block ");
    }
    //The constructor
    public InitialOrderTest() {
        System.out.println(" The constructor ");
    }
    public static void main(String[] args) {
        new InitialOrderTest();
    }
}

The results show that:
A static variable
Static initialization block
variable
The initialization block
The constructor

Rule 2 (with inheritance) :
The initialization of a subclass's static variables and static initializer block is done before the parent class's variables, initializer block, and constructor are initialized

class Parent {
    //A static variable
    public static String p_StaticField = " The parent class -- A static variable ";
    //variable
    public String p_Field = " The parent class -- variable ";
    //Static initialization block
    static {
        System.out.println(p_StaticField);
        System.out.println(" The parent class -- Static initialization block ");
    }
    //The initialization block
    {
        System.out.println(p_Field);
        System.out.println(" The parent class -- The initialization block ");
    }
    //The constructor
    public Parent() {
        System.out.println(" The parent class -- The constructor ");
    }
}//If you want to put the two classes in the same file with the name SubClass, you can't add public before the parent class
public class SubClass extends Parent {　
    //A static variable
    public static String s_StaticField = " A subclass -- A static variable ";
    //variable
    public String s_Field = " A subclass -- variable ";
    //Static initialization block
    static {
        System.out.println(s_StaticField);
        System.out.println(" A subclass -- Static initialization block ");
    }
    //The initialization block
    {
        System.out.println(s_Field);
        System.out.println(" A subclass -- The initialization block ");
    }
    //The constructor
    public SubClass() {
        System.out.println(" A subclass -- The constructor ");
    }
    //Program entrance
    public static void main(String[] args) {
        new SubClass();
    }
}

The results show that:
Parent class - static variables
Parent class - static initialization block
Subclasses -- static variables
Subclass - static initialization block
Parent - variable
Parent class - initializes the block
Parent - constructor
Subclasses -- variables
Subclass -- initializes the block
Subclass -- constructor

Rule 2 (static variables and static initialization blocks) :
Static variables and static initialization blocks are initialized in the order they are defined in the class. Again, variables and primes
The initial block also follows this rule.

public class testOrder {
    //A static variable
    public static TestA a = new TestA();
    public TestC c = new TestC();
    //A static variable
    public static TestB b = new TestB();
    public testOrder(){
        System.out.println("in constract");
    }
    //Static initialization block
    static {
        System.out.println(" Static initialization block ");
    }
    public static void main(String[] args) {
        new testOrder();
    }
}
class TestA {
    public TestA() {
        System.out.println("Test--A");
    }
}
class TestB {
    public TestB() {
        System.out.println("Test--B");
    }
}
class TestC {
    public TestC() {
        System.out.println("Test--C");
    }
}

The results show that:
The Test - A
The Test - B
Static initialization block
The Test - C
In constract

Personal summary:
First static, then son, from top to bottom, first variable and then construction