静态和非静态初始化代码块有什么区别

Question

我的问题是关于 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关键字并使其编译。

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

Answer 1

带有 static 修饰符的代码块表示类初始值设定项； 如果没有 static 修饰符，代码块是一个实例初始值设定项。

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

实例初始化器按照类被实例化时定义的顺序执行，紧接在构造函数代码执行之前，紧接在调用超级构造函数之后。

如果您从int a删除static ，它将成为一个实例变量，您无法从静态初始化程序块访问该变量。 这将无法编译并出现错误“非静态变量 a 无法从静态上下文中引用”。

如果您还从初始化程序块中删除static ，则它会成为实例初始化程序，因此int a在构造时被初始化。

Answer 2

噗！ 什么是静态初始化器？

静态初始值设定项是 java 类中的static {}代码块，仅在调用构造函数或 main 方法之前运行一次。

好的！ 告诉我更多...

• 是任何 java 类中的代码块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 方法中。

希望这可以帮助！

Answer 3

static块是一个“静态初始化器”。

它在类加载时自动调用，并且没有其他方法可以调用它（甚至不能通过反射）。

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

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

Answer 4

这直接来自http://www.programcreek.com/2011/10/java-class-instance-initializers/

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 。 这样可以更容易理解。

代替

int b = 0 ，你可以写

int b;
b = 0;

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

3. 实例初始化器什么时候有用？

实例初始化器的使用很少见，但在以下情况下，它仍然可以作为实例变量初始化器的有用替代：

1. 初始化代码必须处理异常
2. 执行无法用实例变量初始值设定项表示的计算。

当然，这样的代码可以写在构造函数中。 但是如果一个类有多个构造函数，你就必须在每个构造函数中重复代码。

使用实例初始化程序，您只需编写一次代码，无论使用什么构造函数创建对象，它都会执行。 （我猜这只是一个概念，并不经常使用。）

另一个实例初始化器有用的情况是匿名内部类，它根本不能声明任何构造函数。 （这是放置日志功能的好地方吗？）

感谢德海因。

另请注意，实现接口 [1] 的匿名类没有构造函数。 因此，在构造时需要实例初始化器来执行任何类型的表达式。

Answer 5

“final”保证必须在对象初始值设定项代码结束之前初始化变量。 同样，“static final”保证在类初始化代码结束时初始化变量。 从初始化代码中省略“静态”会将其变成对象初始化代码； 因此您的变量不再满足其保证。

Answer 6

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

您可以编写静态初始化程序块以在加载类时初始化静态变量，但此代码可能更复杂。

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

Answer 7

当开发人员使用初始化块时，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
    }
}

我希望我的例子能被开发人员理解。

Answer 8

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

Answer 9

当 JVM 将类加载到内存中并在 main 方法之前调用静态初始化程序块（按照它们定义的顺序）。 它用于有条件地初始化静态变量。

类似地，我们有在对象实例化时调用的实例初始化块（又名 IIB），它们通常用于删除重复的构造函数逻辑。

初始化器和构造器的执行顺序是：

1. 静态初始化块；
2. 对象初始化块；
3. 构造函数；