顺序：
父类静态块-->子类静态块--> main方法-->父类构造代码块 -->父类构造函数-->子类构造代码块-->子类构造函数，同一级别代码块按顺序执行。

这几个名词体现在代码中，如下：

class Study {
    public Study(){
        System.out.println("构造函数");    
    }
    {
        System.out.println("构造代码块");    
    }
    static {
        System.out.println("静态代码块");        
    }
}

静态代码块和代码块的区别在于：
静态代码块只执行一次，代码块每次创建该对象的时候都会执行一次。
执行顺序：
静态变量，main方法，构造块，构造函数。

我觉得对于这个简单明了的理解就是上代码。

普通情况

• 执行顺序，静态变量-->静态块--> main方法

public class Demo {    
    static int a = 10;
    static {
         System.out.println("a----"+a);
         System.out.println("A的静态代码块");
    }
    public static void main(String[] args){
         System.out.println("main");
    }
}

输出结果：
a----10
A的静态代码块
main

• main方法 --> 非静态变量--> 构造代码块 --> 构造函数

public class Demo { 
    static int a = 10;
    static {
         System.out.println("a----"+a);
         System.out.println("A的静态代码块");
    }
    int b = 20;
    {
         System.out.println("b----"+b);
         System.out.println("A的构造代码块");
    }
    Demo(){
        System.out.println("构造函数");
    }
    public static void main(String[] args){
         System.out.println("main");
         new Demo();
    }
}

输出结果：
a----10
A的静态代码块
main
b----20
A的构造代码块
构造函数

• 静态构造块只执行一次，构造代码块每次new对象的时候都会调用。

public class Demo { 

    static {
        System.out.println("子类的静态代码块");
    }
    
    {
        System.out.println("子类的构造代码块");
    }
    Demo(){
        System.out.println("子类构造函数");
    }

    public static void main(String[] args){
        new Demo();
        new Demo();
    }
}

结果：
子类的静态代码块
子类的构造代码块
子类构造函数
子类的构造代码块
子类构造函数

为什么只静态代码块只执行了一次，普通代码块执行了多次？
静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

继承情况

• 父类静态块-->子类静态块--> main方法-->父类构造代码块 -->父类构造函数-->子类构造代码块--> 子类构造函数

class Super {
    static {
        System.out.println("Super的静态代码块");
    }
    {
        System.out.println("Super的构造代码块");
    }
    Super(){
        System.out.println("Super构造函数");
    }

}

public class Demo extends Super{
    static {
        System.out.println("子类的静态代码块1");
    }

    static {
        System.out.println("子类的静态代码块2");
    }
    
    {
        System.out.println("子类的构造代码块");
    }
    Demo(){
        System.out.println("子类构造函数");
    }

    public static void main(String[] args){
        System.out.println("main");
        new Demo();
    }

}

输出:
Super的静态代码块
子类的静态代码块1
子类的静态代码块2
main
Super的构造代码块
Super构造函数
子类的构造代码块
子类构造函数

为什么会调用父类的构造函数呢？命名没有调用过Super方法。
-->子类构造函数会默认调用一下父类的无参构造函数，可以给父类构造函数加个参数试一下。基础知识不能忘啊。

加载过程：
在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Demo类，而在加载Demo类的时候发现Demo类继承自Super类，因此会转去先加载Super类，在加载Super类的时候，发现有static块，便执行了static块。在Super类加载完成之后，便继续加载Demo类，然后发现Demo类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Demo()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。
同时存在两个代码块的时候，按代码顺序执行。

题目

public class Demo {
    private static Demo test = new Demo();
    //静态变量sta1    未赋予初始值
    public static int sta1;
    //静态变量sta1    赋予初始值20
    public static int sta2 = 20;
    //构造方法中对于静态变量赋值
    private Demo() {
        sta1 ++ ;
        sta2 ++ ;
    }
    public static void main(String[] args) {
        System.out.println(Demo.sta1);
        System.out.println(Demo.sta2);
    }
}

print:
1
20
res:都是static就顺序执行，执行完后，让sta1和2自增，完后sta2又赋值为20。
补充一个demo

构造代码块和对象绑定，简单讲，不new对象不走构造代码块

public class Animal {
    private static int k;
    static{
        System.out.println("父类的静态方法");
    }
    {
        System.out.println("执行父类的构造代码块");
    }
    public Animal(){
        System.out.println("执行父类的构造方法");
    }
    public static void main(String[] args) {
        System.out.println(Animal.k);
    }
}
print:
父类的静态方法
0

这个链接里面也有几道烧脑的题目，反正就按顺序来就好了，但是写代码的时候最好还是以大部分人能看明白为主，要不然光这个点很多人就得进坑，而且时间久了自己也会记不牢。
https://www.cnblogs.com/chihirotan/p/6043442.html