static块内的初始化有什么区别：
public class staticTest {
static String s;
static int n;
static double d;
static {
s = "I'm static";
n = 500;
d = 4000.0001;
}
...
个别静态初始化：
public class staticTest {
static String s = "I'm static";
static int n = 500;
static double d = 4000.0001;
....
答案 0 :(得分：77)
静态初始化块允许更复杂的初始化，例如使用条件：
static double a;
static {
if (SomeCondition) {
a = 0;
} else {
a = 1;
}
}
或者当不仅仅需要构造时：使用构建器来创建实例时，除了创建静态字段之外，还需要进行异常处理或工作。
静态初始化块也在内联静态初始化程序之后运行，因此以下内容有效：
static double a;
static double b = 1;
static {
a = b * 4; // Evaluates to 4
}
答案 1 :(得分：16)
典型用法：
private final static Set<String> SET = new HashSet<String>();
static {
SET.add("value1");
SET.add("value2");
SET.add("value3");
}
如果没有静态初始化程序，你会怎么做？
答案 2 :(得分：9)
初始化期间的异常处理是另一个原因。例如：
static URL url;
static {
try {
url = new URL("https://blahblah.com");
}
catch (MalformedURLException mue) {
//log exception or handle otherwise
}
}
这对于烦人地抛出已检查异常的构造函数（如上所述）或者可能容易出现异常的更复杂的初始化逻辑非常有用。
答案 3 :(得分：5)
有时你想做的不仅仅是为静态变量赋值。由于您不能在类体中放置任意语句，因此可以使用静态初始化程序块。
答案 4 :(得分：4)
在你的例子中，没有区别;但通常初始值比在单个表达式中舒适地表达更复杂（例如，它是List<String>，其内容最好由for - 循环表示;或者它是Method可能不存在，因此需要异常处理程序），和/或静态字段需要按特定顺序设置。
答案 5 :(得分：4)
static块可用于初始化 singleton 实例，以防止使用同步 getInstance()方法。
答案 6 :(得分：3)
从技术上讲，没有它就可以逃脱。有些人更喜欢使用多行初始化代码进入静态方法。我很高兴使用静态初始化程序进行相对简单的多语句初始化。
当然，我几乎总是制作我的静力学final并指向一个不可修改的对象。
答案 7 :(得分：2)
静态关键字（无论是变量还是块）属于该类。因此，当调用类时，将执行这些变量或块。所以大多数初始化都是在static关键字的帮助下完成的。因为它属于类本身，所以类可以直接访问它，而无需创建类的实例。
我们举一个例子，有一个鞋类 几个变量，如颜色，大小，品牌等......如果鞋子在这里 制造公司只有一个品牌，而不是我们应该初始化它作为一个品牌 静态变量。所以，当鞋类被称为不同类型 鞋的制造（通过创建一个类的实例）在 每当新鞋出现时，颜色和尺寸都会占据记忆 虽然创造了但是这里的品牌是所有鞋子的共同属性，所以它会 无论生产多少鞋，都会占用一次记忆。
示例：
class Shoe {
int size;
String colour;
static String brand = "Nike";
public Shoe(int size, String colour) {
super();
this.size = size;
this.colour = colour;
}
void displayShoe() {
System.out.printf("%-2d %-8s %s %n",size,colour, brand);
}
public static void main(String args[]) {
Shoe s1 = new Shoe(7, "Blue");
Shoe s2 = new Shoe(8, "White");
System.out.println("=================");
s1.displayShoe();
s2.displayShoe();
System.out.println("=================");
}
}
答案 8 :(得分：2)
您可以在static{}内使用try / catch块，如下所示：
MyCode{
static Scanner input = new Scanner(System.in);
static boolean flag = true;
static int B = input.nextInt();
static int H = input.nextInt();
static{
try{
if(B <= 0 || H <= 0){
flag = false;
throw new Exception("Breadth and height must be positive");
}
}catch(Exception e){
System.out.println(e);
}
}
}
PS：引用自this！
答案 9 :(得分：0)
静态代码块可以使用多个函数初始化字段，以不同的声明顺序初始化字段，也可以用于条件初始化。
更具体地说，
static final String ab = a+b;
static final String a = "Hello,";
static final String b = ", world";
不起作用，因为a和b是在ab。
之后声明的但是我可以使用静态init。阻止克服这个。
static final String ab;
static final String a;
static final String b;
static {
b = ", world";
a = "Hello";
ab = a + b;
}
static final String ab;
static final String a;
static final String b;
static {
b = (...) ? ", world" : ", universe";
a = "Hello";
ab = a + b;
}
答案 10 :(得分：0)
如果您希望在类首次使用之前初始化指定的类静态类型，则静态初始化块很有用。后续使用不会调用任何静态初始化块。它与实例初始化器直接相反，后者初始化实例成员。
答案 11 :(得分：0)
我们使用构造函数初始化我们的实例变量（非静态变量，属于对象的变量，而不是类）。
如果要初始化类变量（静态变量）并且想要在不创建对象的情况下执行它（构造函数只能在创建对象时调用），那么您需要静态块。
static Scanner input = new Scanner(System.in);
static int widht;
static int height;
static
{
widht = input.nextInt();
input.nextLine();
height = input.nextInt();
input.close();
if ((widht < 0) || (height < 0))
{
System.out.println("java.lang.Exception: Width and height must be positive");
}
else
{
System.out.println("widht * height");
}
}
答案 12 :(得分：0)
当您要在类加载时评估任何表达式时，可以使用静态块，但请记住：
您必须在静态块中处理异常，这意味着您不能从静态块引发异常。
答案 13 :(得分：0)
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
static Scanner sc=new Scanner(System.in);
public static int B=sc.nextInt();
public static int H=sc.nextInt();
public static boolean flag=false;
static
{
if(B>0 && H>0)
{
flag=true;
}
else
{
System.out.print("java.lang.Exception: Breadth and height must be positive");
}
}
public static void main(String[] args){
if(flag)
{
int area=B*H;
System.out.print(area);
}
}//end of main
}//end of class