由"反射的三种方式的区别"引发的知识泥石流

问题来自于反射的三种方式的区别在哪里，由此牵出“构造代码块”这样一个概念，再深究下去就来到了类的加载过程，所以最终还是java虚拟机。
首先是反射的三种方式的区别：

1.类名.class
不做类的初始化工作，返回类的Class对象。
2.Class.forName(String className)
做类的静态初始化，返回类的Class对象。（ 如果使用Class.forName(String name, boolean initialize,ClassLoader loader) ，并将initialize的值设为false，则不会进行类的静态初始化）
3.实例对象的getClass()
对类进行静态初始化、非静态初始化（由于首先使用new得到类的实例对象，实际上是这一步对类进行了初始化）。

(以下大部分内容来自于文章：https://cloud.tencent.com/developer/article/1350200，很感谢这位大牛的总结，但是结尾部分，他写错了。。。)

public class Test {
    {
        ////
    }
}

这种形式的程序段我们将其称之为代码块，所谓代码块就是用大括号({})将多行代码封装在一起，形成一个独立的数据体，用于实现特定的算法。一般来说代码块是不能单独运行的，它必须要有运行主体。在Java中代码块主要分为四种：

一、普通代码块

普通代码块是我们用得最多的也是最普遍的，它就是在方法名后面用{}括起来的代码段。普通代码块是不能够单独存在的，它必须要紧跟在方法名后面。同时也必须要使用方法名调用它。

public class Test {
    public void test(){
        System.out.println("普通代码块");
    }
}

二、静态代码块

想到静态我们就会想到static，静态代码块就是用static修饰的用{}括起来的代码段，它的主要目的就是对静态属性进行初始化

public class Test {
    static{
        System.out.println("静态代码块");
    }
}

三、同步代码块

使用 synchronized 关键字修饰，并使用“{}”括起来的代码片段，它表示同一时间只能有一个线程进入到该方法块中，是一种多线程保护机制。

四、构造代码块

在类中直接定义没有任何修饰符、前缀、后缀的代码块即为构造代码块。

public class Test {
    {
        System.out.println("构造代码块");
    }
}

它的主要作用有两个：

1. 初始化实例变量
   如果一个类中存在若干个构造函数，这些构造函数都需要对实例变量进行初始化，如果我们直接在构造函数中实例化，必定会产生很多重复代码，繁琐和可读性差。这里我们可以充分利用构造代码块来实现。这是利用编译器会将构造代码块添加到每个构造函数中的特性。
2. 初始化实例环境
   一个对象必须在适当的场景下才能存在，如果没有适当的场景，则就需要在创建对象时创建此场景。我们可以利用构造代码块来创建此场景，尤其是该场景的创建过程较为复杂。构造代码会在构造函数之前执行。

上面两个常用场景都充分利用构造代码块的特性，能够很好的解决在实例化对象时构造函数比较难解决的问题，利用构造代码不仅可以减少代码量，同时也是程序的 可读性增强了。特别是当一个对象的创建过程比较复杂，需要实现一些复杂逻辑，这个时候如果在构造函数中实现逻辑，这是不推荐的，因为我们提倡构造函数要尽 可能的简单易懂，所以我们可以使用构造代码封装这些逻辑实现部分。

五、静态代码块、构造代码块、构造函数执行顺序

从词面上我们就可以看出他们的区别。静态代码块，静态，其作用级别为类，构造代码块、构造函数，构造，其作用级别为对象。

1. 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一次，主要用于给类进行初始化。
2. 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同对象共性的初始化内容和初始化实例环境。
3. 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而构造代码是给所有对象进行初始化，作用区域不同。

通过上面的分析，他们三者的执行顺序应该为：静态代码块 > 构造代码块 > 构造函数。

public class Test {
    /**
     * 静态代码块
     */
    static{
        System.out.println("执行静态代码块...");
    }

    /**
     * 构造代码块
     */
    {
        System.out.println("执行构造代码块...");
    }

    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }

    /**
     * 有参构造函数
     * @param id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }

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

Output:
执行静态代码块…
———————-
执行构造代码块…
执行无参构造函数…
———————-
执行构造代码块…
执行有参构造函数…

六、复杂环境下的执行顺序

一道亚信面试题（经过原作者的修改）：

class Print{
 public Print(String message) {
     System.out.println(message);
 }
}
class Parent{
 //静态属性
 private static Print name1 = new Print("Parent static field");
 //属性（成员变量）
 private Print name2 = new Print("Parent field");
 //构造器
 public Parent(){
     System.out.println("Parent constructor");
 }
 //静态代码块
 static{
     new Print("Parent static code block");
 }
 //构造代码块
 {
     new Print("Parent constructor code block");
 }
}
public class Child extends Parent{
 //静态属性
 private static Print name1 = new Print("Child static field");
 //属性（成员变量）
 private Print name2 = new Print("Child field");
 //构造器
 public Child(){
     System.out.println("Child constructor");
 }
 //静态代码块
 static{
     new Print("Child static code block");
 }
 //构造代码块
 {
     new Print("Child constructor code block");
 }
 public static void main(String[] args) {
     new Child();
     System.out.println("---我是分割线---");
     new Child();
 }
}

原文的结果我就不展示了，直接贴正确结果：

Parent static field
Parent static code block
Child static field
Child static code block
Parent field
Parent constructor code block
Parent constructor
Child field
Child constructor code block
Child constructor
—我是分割线—
Parent field
Parent constructor code block
Parent constructor
Child field
Child constructor code block
Child constructor