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


357

我的问题是关于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关键字,它将抱怨,因为变量afinal。但是,可以同时删除finalstatic关键字并进行编译。

这两种方式都使我感到困惑。我应该如何拥有不属于任何方法的代码段?如何调用它?通常,此用法的目的是什么?或者更好的是,在哪里可以找到有关此文件的文档?

Answers:


403

带有static修饰符的代码块表示初始化程序;没有静态修饰符的代码块是实例初始化程序。

当加载类时(实际上是在解决时,这是技术性的),按定义的顺序执行类初始化器(自上而下,就像简单的变量初始化器一样)。

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

如果删除 static从中int a,它将成为一个实例变量,您将无法从静态初始值设定项块中访问该实例变量。这将无法通过错误“无法从静态上下文引用非静态变量a”进行编译。

如果您还static从初始化程序块中删除,则它将变为实例初始化程序,因此int a在构造时进行了初始化。


静态初始化器实际上是在类被加载和链接后,在以后初始化时实际调用的。当您实例化一个类的对象或访问该类上的静态变量或方法时,就会发生这种情况。实际上,如果您有一个带有静态初始化程序和方法的类public static void staticMethod(){},则可以执行TestStatic.class.getMethod("staticMethod");。静态初始值设定项不会被调用。这里更多信息docs.oracle.com/javase/specs/jvms/se10/html/...
TOTO

@Totò:是的,这就是类的解析度所需要的(至少他们以前将其称为link + init称为“解析度”)。我不惊讶您可以使用反射来发现有关某个类的内容而无需解决。
劳伦斯·多尔

166

ff!什么是静态初始值设定项?

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

好!告诉我更多...

  • static { ... }任何Java类中的代码块。并在调用class时由虚拟机执行。
  • return支持任何语句。
  • 不支持任何参数。
  • thissuper不受支持。

嗯,在哪里可以使用?

可以在任何感觉还可以的地方使用:)如此简单。但是我看到在数据库连接,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.");
    }
}

输出???

内部静态初始化器。

苹果

橙子

结束静态初始化程序。

内部主要方法。

希望这可以帮助!


谢谢马丹!可以静态块被用来代替afterPropertiesSet()InitializingBean
Alexander Suraphel 2015年

3
是的你可以!当类由jvm加载时,将调用静态初始化程序。因此,这实际上是执行代码的第一阶段。如果您也有构造函数,则顺序为:静态初始值设定项,构造函数,afterPropertiesSet
Martin Baumgartner

57

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

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

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

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

6
不会,没有明确的调用方式,类初始化器永远不会由Method实例表示,而只能由Java虚拟机调用。
拉斐尔·温特豪德2014年

46

这直接来自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]的匿名类没有构造函数。因此,在构造时需要实例初始化程序来执行任何类型的表达式。


12

“最终”保证必须在对象初始化程序代码结束之前初始化变量。同样,“ static final”保证变量将在类初始化代码的末尾进行初始化。从初始化代码中省略“静态”将把它变成对象初始化代码。因此,您的变量不再满足其保证。


8

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

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

静态初始化程序块看起来像没有名称,没有参数且没有返回类型的方法。由于您从不调用它,因此不需要名称。它唯一的调用是在虚拟机加载类时。


6

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

我希望开发人员可以理解我的示例。


4

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


作为后续,如果我不创建对象的实例,而是调用公共静态函数。是否暗示可以保证在此公共函数调用之前执行此块?谢谢。
Szere Dyeri's

如果调用该类的公共静态函数,则需要首先加载该类,因此,是的,静态初始化程序将首先执行。
Paul Tomblin

除非是类初始化(间接)调用了试图使用它的代码。IFYSWIM。循环依赖等等。
Tom Hawtin-大头钉

1
@Tom是正确的-可以编写一些内容,其中一个静态初始值设定项在调用另一个静态初始值设定项之前调用一个静态方法,但我的想法后退,因此我从未考虑过。
Paul Tomblin,
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.