带有static修饰符的代码块表示 class 初始化式;没有static修饰符，代码块是一个 instance 初始化器。
当类被加载时（实际上，当它被解析时，但那是技术性的），类初始化器按照它们被定义的顺序执行（自上而下，就像简单的变量初始化器一样）。
示例初始化器按照类示例化时定义的顺序执行，在构造函数代码执行之前，在调用超构造函数之后。
如果从int a中删除static，它将成为一个示例变量，您无法从静态初始化程序块访问它。这将导致编译失败，并出现错误“non-static variable a cannot be reference from a static context”。
如果你也从初始化器块中移除static，那么它就变成了一个示例初始化器，所以int a在构造时被初始化。

Uff！什么是静态初始化器？

静态初始化器是java类内部的一个static {}代码块，在调用构造函数或main方法之前只运行一次。

好吧，告诉我更多

• 是任何java类中的代码块static { ... }，并在调用类时由虚拟机执行。
• 不支持return语句。
• 不支持任何参数。
• 不支持this或super。
  我能在哪里用

可以在任何你觉得合适的地方使用：）就是这么简单。但是我发现大多数时候它都是在做数据库连接，API初始化，日志记录等等的时候使用的。
"别光叫，榜样在哪里"

package com.example.learnjava;

import java.util.ArrayList;

public class Fruit {

    static {
        System.out.println("Inside Static Initializer.");

        // fruits array
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Orange");
        fruits.add("Pear");

        // print fruits
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        System.out.println("End Static Initializer.\n");
    }

    public static void main(String[] args) {
        System.out.println("Inside Main Method.");
    }
}

输出？？？

在静态初始值设定项内部。
苹果
橙子
梨
结束静态初始值设定项。
在Main方法内部。

static块是一个“静态初始化器”。
当类被加载时，它被自动调用，没有其他方法可以调用它（甚至不能通过Reflection）。
我个人只在编写JNI代码时使用过它：

class JNIGlue {
    static {
        System.loadLibrary("foo");
    }
}

这是直接来自http://www.programcreek.com/2011/10/java-class-instance-initializers/的

1.执行顺序

看看下面的类，你知道哪个类先执行吗？

public class Foo {
 
    //instance variable initializer
    String s = "abc";
 
    //constructor
    public Foo() {
        System.out.println("constructor called");
    }
 
    //static initializer
    static {
        System.out.println("static initializer called");
    }
 
    //instance initializer
    {
        System.out.println("instance initializer called");
    }
 
    public static void main(String[] args) {
        new Foo();
        new Foo();
    }
}

输出：
调用了静态初始值设定项
示例初始值设定项已调用
构造函数调用
示例初始值设定项已调用
构造函数调用

2. Java示例初始化器是如何工作的？

上面的示例初始化器包含了一个println语句，为了理解它的工作原理，我们可以把它当作一个变量赋值语句，例如b = 0，这样可以使它更容易理解。
代替
int b = 0，你可以写

int b;
b = 0;

因此，示例初始化器和示例变量初始化器几乎是相同的。

3.示例初始化器何时有用？

示例初始化式的使用很少，但在以下情况下，它仍然是示例变量初始化式的有用替代方法：
1.初始化程序代码必须处理异常
1.执行无法用示例变量初始化式表示的计算。
当然，这样的代码可以用构造函数来编写，但是如果一个类有多个构造函数，你就必须在每个构造函数中重复代码。
有了示例初始化器，你只需要写一次代码，不管用什么构造函数来创建对象，它都会被执行（我猜这只是一个概念，并不经常使用）。
示例初始化式有用的另一种情况是匿名内部类，它根本不能声明任何构造函数（这是放置日志函数的好地方吗？）
多亏了德海因。
还要注意实现接口[1]的匿名类没有构造函数。因此在构造时需要示例初始化器来执行任何类型的表达式。

“final”保证变量必须在对象初始化器代码结束之前初始化。同样，“static final”保证变量将在类初始化代码结束之前初始化。从初始化代码中省略“static”会将其转换为对象初始化代码;因此你的变量不再满足它的保证。

你不会把代码写进一个需要在程序中任何地方被调用的静态块中。如果代码的目的是被调用，那么你必须把它放在一个方法中。
可以编写静态初始化器块来在加载类时初始化静态变量，但此代码可能会更复杂。
一个静态初始化块看起来像一个没有名字，没有参数，也没有返回类型的方法。因为你从来没有调用过它，所以它不需要名字。唯一一次调用它是在虚拟机加载类的时候。

当开发者使用初始化器块时，Java编译器将初始化器复制到当前类的每个构造函数中。
示例：
以下代码：

class MyClass {

    private int myField = 3;
    {
        myField = myField + 2;
        //myField is worth 5 for all instance
    }

    public MyClass() {
        myField = myField * 4;
        //myField is worth 20 for all instance initialized with this construtor
    }

    public MyClass(int _myParam) {
        if (_myParam > 0) {
            myField = myField * 4;
            //myField is worth 20 for all instance initialized with this construtor
            //if _myParam is greater than 0
        } else {
            myField = myField + 5;
            //myField is worth 10 for all instance initialized with this construtor
            //if _myParam is lower than 0 or if _myParam is worth 0
        }
    }

    public void setMyField(int _myField) {
        myField = _myField;
    }

    public int getMyField() {
        return myField;
    }
}

public class MainClass{

    public static void main(String[] args) {
        MyClass myFirstInstance_ = new MyClass();
        System.out.println(myFirstInstance_.getMyField());//20
        MyClass mySecondInstance_ = new MyClass(1);
        System.out.println(mySecondInstance_.getMyField());//20
        MyClass myThirdInstance_ = new MyClass(-1);
        System.out.println(myThirdInstance_.getMyField());//10
    }
}

相当于：

class MyClass {

    private int myField = 3;

    public MyClass() {
        myField = myField + 2;
        myField = myField * 4;
        //myField is worth 20 for all instance initialized with this construtor
    }

    public MyClass(int _myParam) {
        myField = myField + 2;
        if (_myParam > 0) {
            myField = myField * 4;
            //myField is worth 20 for all instance initialized with this construtor
            //if _myParam is greater than 0
        } else {
            myField = myField + 5;
            //myField is worth 10 for all instance initialized with this construtor
            //if _myParam is lower than 0 or if _myParam is worth 0
        }
    }

    public void setMyField(int _myField) {
        myField = _myField;
    }

    public int getMyField() {
        return myField;
    }
}

public class MainClass{

    public static void main(String[] args) {
        MyClass myFirstInstance_ = new MyClass();
        System.out.println(myFirstInstance_.getMyField());//20
        MyClass mySecondInstance_ = new MyClass(1);
        System.out.println(mySecondInstance_.getMyField());//20
        MyClass myThirdInstance_ = new MyClass(-1);
        System.out.println(myThirdInstance_.getMyField());//10
    }
}

我希望开发人员能够理解我的示例。

静态代码块可用于示例化或初始化类变量（与对象变量相反）。因此声明“a”为静态意味着只有一个被所有Test对象共享，并且静态代码块仅在Test类首次加载时初始化“a”一次，无论创建了多少Test对象。

当JVM将类加载到内存中时，在main方法之前调用 *static初始化器块 *（按照定义它们的顺序）。它用于有条件地初始化静态变量。
类似地，我们有在对象示例化时调用的 * 示例初始化器块 *（aka IIB），它们通常用于删除重复的构造器逻辑。
初始值设定项和构造函数的执行顺序为：
1.静态初始值设定项块;
1.对象初始值设定项块;
1.施工人员;