我的问题是关于静态关键字的一种特殊用法。可以使用static 关键字来覆盖类中不属于任何函数的代码块。例如下面的代码编译：
public class Test {
private static final int a;
static {
a = 5;
doSomething(a);
}
private static int doSomething(int x) {
return (x+5);
}
}
如果您删除 static 关键字，它会报错，因为变量 a 是 final。但是，可以同时删除 final 和 static 关键字并使其编译。
这两种方式都让我感到困惑。我应该如何拥有一个不属于任何方法的代码部分？怎么可能调用它？一般来说，这种用法的目的是什么？或者更好的是，我在哪里可以找到这方面的文档？
【问题讨论】：
标签： java static static-initializer
带有static修饰符的代码块表示一个类初始化器；如果没有 static 修饰符，代码块是一个 instance 初始化器。
类初始化器在加载类时（实际上是解析时）按照它们定义的顺序执行（自上而下，就像简单的变量初始化器一样）。
实例初始化程序按照类被实例化时定义的顺序执行，紧接在执行构造函数代码之前，紧接在调用超级构造函数之后。
如果您从int a 中删除static，它将成为一个实例变量，您无法从静态初始化程序块访问它。这将无法编译，并出现错误“无法从静态上下文引用非静态变量 a”。
如果您还从初始化程序块中删除static，它就会成为实例初始化程序，因此int a 在构造时被初始化。
【讨论】：
public static void staticMethod(){}，如果你执行TestStatic.class.getMethod("staticMethod");。不会调用静态初始化程序。更多信息在这里docs.oracle.com/javase/specs/jvms/se10/html/…
嘘！什么是静态初始化器？
静态初始化器是java类中的static {}代码块，在构造函数或main方法被调用之前只运行一次。
好的！告诉我更多...
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 方法中。
希望这会有所帮助！
【讨论】：
afterPropertiesSet() 的InitializingBean 吗？
static 块是一个“静态初始化器”。
加载类时会自动调用它，并且没有其他方法可以调用它（甚至不能通过反射）。
我个人只在编写 JNI 代码时使用过它：
class JNIGlue {
static {
System.loadLibrary("foo");
}
}
【讨论】：
Method 实例表示，而只能由 Java 虚拟机调用。
这是直接来自http://www.programcreek.com/2011/10/java-class-instance-initializers/
看看下面这个类，你知道哪个是最先执行的吗？
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();
}
}
输出：
调用静态初始化器
调用实例初始化器
构造函数调用
调用实例初始化器
构造函数调用
上面的实例初始化器包含一个 println 语句。为了理解它是如何工作的，我们可以把它当作一个变量赋值语句，例如，b = 0。这可以使其更容易理解。
代替
int b = 0，你可以写
int b;
b = 0;
因此，实例初始化器和实例变量初始化器几乎相同。
实例初始化器的使用很少见，但它仍然可以作为实例变量初始化器的有用替代方案：
当然，这样的代码可以写在构造函数中。但是如果一个类有多个构造函数，你就必须在每个构造函数中重复代码。
使用实例初始化器，您只需编写一次代码，无论使用什么构造函数创建对象，它都会执行。 （我猜这只是一个概念，并不经常使用。）
实例初始化器有用的另一种情况是匿名内部类，它根本不能声明任何构造函数。 （这会是一个放置日志功能的好地方吗？）
感谢德莱恩。
还要注意，实现接口 [1] 的匿名类没有构造函数。因此，在构造时需要实例初始化器来执行任何类型的表达式。
【讨论】：
"final" 保证必须在对象初始化程序代码结束之前初始化变量。同样，“静态最终”保证变量将在类初始化代码结束时被初始化。从初始化代码中省略“静态”会将其转换为对象初始化代码；因此你的变量不再满足它的保证。
【讨论】：
您不会将代码写入需要在程序中的任何位置调用的静态块。如果要调用代码的目的，则必须将其放在方法中。
您可以编写静态初始化程序块来在加载类时初始化静态变量，但此代码可能更复杂..
静态初始化程序块看起来像一个没有名称、没有参数和没有返回类型的方法。由于您从不调用它，因此不需要名称。它的唯一调用时间是在虚拟机加载类时。
【讨论】：
当开发人员使用初始化程序块时，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对象共享，并且静态代码块只初始化“a”一次，当Test类第一次加载时，不管创建了多少Test对象。
【讨论】：