据我所知,“静态初始化块”是用来设置静态字段的值,如果它不能在一行中完成。

但我不明白为什么我们需要一种特殊的积木。例如,我们将一个字段声明为静态(没有赋值)。然后写几行代码,生成并赋值给上面声明的静态字段。

为什么我们需要这些行在一个特殊的块,如:static{…}?


当前回答

我认为静态块只是语法糖。你不能用静态块做什么,也不能用其他任何东西。

重复使用这里发布的一些例子。

这段代码可以在不使用静态初始化器的情况下重写。

方法1:使用静态

private static final HashMap<String, String> MAP;
static {
    MAP.put("banana", "honey");
    MAP.put("peanut butter", "jelly");
    MAP.put("rice", "beans");
  }

方法2:无静电

private static final HashMap<String, String> MAP = getMap();
private static HashMap<String, String> getMap()
{
    HashMap<String, String> ret = new HashMap<>();
    ret.put("banana", "honey");
    ret.put("peanut butter", "jelly");
    ret.put("rice", "beans");
    return ret;
}

其他回答

静态块用于任何以动态方式初始化静态数据成员的技术,或者我们可以说静态数据成员的动态初始化使用静态块,因为对于非静态数据成员初始化,我们有构造函数,但没有任何地方可以动态初始化静态数据成员

Eg:-class Solution{
         // static int x=10;
           static int x;
       static{
        try{
          x=System.out.println();
          }
         catch(Exception e){}
        }
       }

     class Solution1{
      public static void main(String a[]){
      System.out.println(Solution.x);
        }
        }

现在我的静态int x将动态初始化..Bcoz时,编译器将去解决方案。因此,我们可以动态地初始化静态数据成员。

}

有几个实际的原因,它必须存在:

初始化静态final成员,其初始化可能引发异常 用计算值初始化静态final成员

人们倾向于使用静态{}块作为一种方便的方式来初始化类在运行时所依赖的东西——比如确保特定的类被加载(例如JDBC驱动程序)。这可以通过其他方式来实现;然而,我上面提到的两件事只能用静态{}块这样的构造来完成。

这里有一个例子:

  private static final HashMap<String, String> MAP = new HashMap<String, String>();
  static {
    MAP.put("banana", "honey");
    MAP.put("peanut butter", "jelly");
    MAP.put("rice", "beans");
  }

“静态”部分中的代码将在类加载时执行,在构造类的任何实例之前(并且在从其他地方调用任何静态方法之前)。这样可以确保类资源都准备好使用了。

也可以使用非静态初始化块。它们的作用类似于为该类定义的构造函数方法集的扩展。它们看起来就像静态初始化块,除了关键字“static”被省略了。

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");
    } 
}

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

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;
    }
}

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