Code:

class A {
    static {
        System.out.println("Static init A.");
    }

    {
        System.out.println("Instance init A.");
    }

    A() {
        System.out.println("Constructor A.");
    }
}

class B extends A {
    static {
        System.out.println("Static init B.");
    }

    {
        System.out.println("Instance init B.");
    }

    B() {
        System.out.println("Constructor B.");
    }
}

class C extends B {

    static {
        System.out.println("Static init C.");
    }

    {
        System.out.println("Instance init C.");
    }

    C() {
        System.out.println("Constructor C.");
    }
}

public class Test2 {

    static {
        System.out.println("Static init Test2.");
    }

    {
        System.out.println("Instance init Test2.");
    }

    public Test2() {
        System.out.println("Constructor Test2.");
    }

    public static void main(String[] args) {
        C c = new C();
        C C1 = new C();
    }
}

Output:

Static init Test2.
Static init A.
Static init B.
Static init C.
Instance init A.
Constructor A.
Instance init B.
Constructor B.
Instance init C.
Constructor C.
Instance init A.
Constructor A.
Instance init B.
Constructor B.
Instance init C.
Constructor C.

From the above results, we can see that:
All static initialization blocks are executed first, followed by non static initialization blocks and constructors. Their execution order is:
Static initialization block of parent class
Static initialization block of subclass
Initialization block of parent class
Constructor of the parent class
Initialization block of subclass
Constructor of subclass

summary

Static initialization blocks have the highest priority, that is, they are executed first, and only when the class is first loaded.
It is executed after the non static initialization of the block and constructor, and once every time the object is generated;
The code for a non static initialization block is executed before the class constructor. Therefore, if you want to use it, you should form the habit of writing the initialization block before the constructor for debugging.
Static initialization block can be used to initialize static member variables or execute initialization code.
Nonstatic initialization blocks can be reused for multiple overloaded constructors.

Reference resources: