非静态块:

{
    // Do Something...
}

每次构造类的实例时调用。静态块只被调用一次，当类本身初始化时，不管你创建了多少这种类型的对象。

例子:

public class Test {

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

    {
        System.out.println("Non-static block");
    }

    public static void main(String[] args) {
        Test t = new Test();
        Test t2 = new Test();
    }
}

这个打印:

Static
Non-static block
Non-static block

如果你的静态变量需要在运行时设置，那么一个静态{…} block非常有用。

例如，如果您需要将static成员设置为存储在配置文件或数据库中的值。

当您想要向静态Map成员添加值时也很有用，因为您不能在初始成员声明中添加这些值。

作为补充，就像@Pointy说的

“静态”部分中的代码将在类加载时执行 时间，在构造类的任何实例之前(以及在 任何静态方法都从其他地方调用)。

它应该将System.loadLibrary("I_am_native_library")添加到静态块中。

static{
    System.loadLibrary("I_am_a_library");
}

它将保证在相关库加载到内存之前不调用本机方法。

根据oracle的loadLibrary:

如果使用相同的库名多次调用此方法， 第二次和随后的调用将被忽略。

所以很意外地，把系统。不使用loadLibrary以避免库被多次加载。

如果它们不在静态初始化块中，它们会在哪里?如何声明一个只用于初始化的局部变量，并将其与字段区分开来?例如，你想怎么写:

public class Foo {
    private static final int widgets;

    static {
        int first = Widgets.getFirstCount();
        int second = Widgets.getSecondCount();
        // Imagine more complex logic here which really used first/second
        widgets = first + second;
    }
}

如果第一个和第二个不在一个块中，它们看起来就像字段。如果它们在一个前面没有static的块中，这将被算作实例初始化块，而不是静态初始化块，因此它将在每个构造的实例中执行一次，而不是总共执行一次。

现在在这个特殊的情况下，你可以使用一个静态方法:

public class Foo {
    private static final int widgets = getWidgets();

    static int getWidgets() {
        int first = Widgets.getFirstCount();
        int second = Widgets.getSecondCount();
        // Imagine more complex logic here which really used first/second
        return first + second;
    }
}

．.． 但是当你希望在同一个块中分配多个变量时，或者没有变量时(例如，如果你只是想记录一些东西-或者可能初始化一个本机库)，这就不起作用了。

认为静态块只能访问静态字段是一种常见的误解。为此，我想展示下面一段我在现实项目中经常使用的代码(部分复制自另一个略有不同的上下文的答案):

public enum Language { 
  ENGLISH("eng", "en", "en_GB", "en_US"),   
  GERMAN("de", "ge"),   
  CROATIAN("hr", "cro"),   
  RUSSIAN("ru"),
  BELGIAN("be",";-)");

  static final private Map<String,Language> ALIAS_MAP = new HashMap<String,Language>(); 
  static { 
    for (Language l:Language.values()) { 
      // ignoring the case by normalizing to uppercase
      ALIAS_MAP.put(l.name().toUpperCase(),l); 
      for (String alias:l.aliases) ALIAS_MAP.put(alias.toUpperCase(),l); 
    } 
  } 

  static public boolean has(String value) { 
    // ignoring the case by normalizing to uppercase
    return ALIAS_MAP.containsKey(value.toUpper()); 
  } 

  static public Language fromString(String value) { 
    if (value == null) throw new NullPointerException("alias null"); 
    Language l = ALIAS_MAP.get(value); 
    if (l == null) throw new IllegalArgumentException("Not an alias: "+value); 
    return l; 
  } 

  private List<String> aliases; 
  private Language(String... aliases) { 
    this.aliases = Arrays.asList(aliases); 
  } 
} 

这里，初始化式用于维护一个索引(ALIAS_MAP)，将一组别名映射回原始enum类型。它的目的是作为枚举本身提供的内置valueOf方法的扩展。

如您所见，静态初始化器甚至可以访问私有字段别名。重要的是要理解静态块已经可以访问Enum值实例(例如ENGLISH)。这是因为在Enum类型的情况下，初始化和执行的顺序，就像静态私有字段在调用静态块之前已经被实例初始化一样:

Enum常量是隐式静态字段。这需要Enum构造函数和实例块，并且实例初始化也首先发生。 静态块和初始化静态字段的出现顺序。

注意这种乱序初始化(构造函数在静态块之前)非常重要。当我们用类似于Singleton的实例初始化静态字段时(做了简化)也会发生:

public class Foo {
  static { System.out.println("Static Block 1"); }
  public static final Foo FOO = new Foo();
  static { System.out.println("Static Block 2"); }
  public Foo() { System.out.println("Constructor"); }
  static public void main(String p[]) {
    System.out.println("In Main");
    new Foo();
  }
}

我们看到的输出如下:

Static Block 1
Constructor
Static Block 2
In Main
Constructor

明确的是静态初始化实际上可以发生在构造函数之前，甚至之后:

简单地在主方法中访问Foo，会导致类被加载并开始静态初始化。但是作为静态初始化的一部分，我们再次调用静态字段的构造函数，之后它恢复静态初始化，并完成从主方法中调用的构造函数。相当复杂的情况，我希望在正常的编码中我们不需要处理。

有关这方面的更多信息，请参阅《Effective Java》一书。

static int B,H;
static boolean flag = true;
static{
    Scanner scan = new Scanner(System.in);
    B = scan.nextInt();
    scan.nextLine();
    H = scan.nextInt();

    if(B < 0 || H < 0){
        flag = false;
        System.out.println("java.lang.Exception: Breadth and height must be positive");
    } 
}