Java 静态和非静态初始化代码块之间的区别是什么

我的问题是关于static关键字的一个特殊用法。可以使用

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

关键字并使其编译

---

这两方面都让我感到困惑。我怎么能拥有一个不属于任何方法的代码段？怎么可能调用它？一般来说，这种用法的目的是什么？或者更好，我在哪里可以找到关于这个的文档？

静态块是一个“静态初始值设定项”

它是在类被加载时自动调用的，并且没有其他方法来调用它（甚至不是通过反射）

我个人只在编写JNI代码时使用过它：

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

---

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

您不会将代码写入需要在程序中任何位置调用的静态块中。如果要调用代码，则必须将其放置在方法中

加载类时，可以编写静态初始值设定项块来初始化静态变量，但此代码可能更复杂

---

静态初始值设定项块看起来像一个没有名称、没有参数和没有返回类型的方法。因为你从来不叫它，所以它不需要名字。调用它的唯一时间是虚拟机加载类时。

带有静态修饰符的代码块表示类初始值设定项；如果没有静态修饰符，代码块就是实例初始值设定项

类初始值设定项在类被加载时（实际上，当它被解析时，但这是一个技术性问题）按照它们被定义的顺序执行（自上而下，就像简单的变量初始值设定项一样）

实例初始值设定项按照实例化类时定义的顺序执行，在执行构造函数代码之前，在调用超级构造函数之后

如果从

int a

中删除

static

，它将成为一个实例变量，您无法从静态初始值设定项块访问该变量。这将无法编译，错误为“无法从静态上下文引用非静态变量a”

---

如果还从初始值设定项块中删除

static

，则它将成为实例初始值设定项，因此

int a

将在构造时初始化。

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

---

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

Uff！什么是静态初始值设定项？

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

静态初始值设定项是java类中的一个

static{}

代码块，在调用构造函数或main方法之前只运行一次

好的！告诉我更多…

• 是任何java类中的代码块

  static{…}

  。并在调用类时由虚拟机执行
• 不支持任何

  return

  语句
• 不支持任何参数
• 不支持

  此

  或

  超级

嗯，我在哪里可以使用它？

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

可以在任何你觉得合适的地方使用：）很简单。但我看到大多数情况下，它是在进行数据库连接、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.");
    }
}

package com.example.learnjava；
导入java.util.ArrayList；
公共级水果{
静止的{
System.out.println（“内部静态初始值设定项”）；
//水果阵列
ArrayList=新的ArrayList（）；
水果。添加（“苹果”）；
水果。添加（“橙色”）；
水果。添加（“梨”）；
//印刷水果
用于（串水果：水果）{
系统输出打印（水果）；
}
System.out.println（“结束静态初始值设定项。\n”）；
}
公共静态void main（字符串[]args）{
System.out.println（“内部主方法”）；
}
}

输出？？？

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

内部静态初始化器

苹果

橙色的

梨

结束静态初始值设定项

内主法

希望这有帮助

这是直接从

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

。这可以使理解变得更加明显

而不是

intb=0

，您可以编写

int b;
b = 0;

因此，实例初始值设定项和实例变量初始值设定项几乎相同

3.实例初始值设定项何时有用？ 实例初始值设定项的使用