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

我的问题是关于静态关键字的一个特殊用法。可以使用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关键字并使其编译。

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

253013 次浏览
小开

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

它在类加载时被自动调用，并且没有其他方法来调用它(甚至通过反射)。

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

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

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

小开

您不会将代码写入需要在程序中的任何地方调用的静态块中。如果代码的目的是被调用，那么必须将它放在方法中。

你可以写静态初始化块来初始化静态变量当类加载时，但这段代码可能更复杂。

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

小开
最佳答案

带有静态修饰符的代码块表示类初始化式;如果没有静态修饰符，代码块是实例初始化式。

类初始化器在装入类时(实际上是在解析类时，但这是一个技术术语)按照它们定义的顺序执行(自顶向下，就像简单的变量初始化器一样)。

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

如果你从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
}
}

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

小开

风浪!什么是静态初始化器?

静态初始化式是java类中的static {}代码块，在构造函数或主方法被调用之前只运行一次。

好的!告诉我更多……

  • 是任何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 Method内部。

希望这能有所帮助!

小开

这直接来自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. 执行无法用实例变量初始化式表示的计算。

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

使用实例初始化式，只需编写一次代码，无论使用什么构造函数创建对象，它都将被执行。(我猜这只是一个概念，并不常用。)

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

感谢Derhein。

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

小开

静态初始化块在JVM将类装入内存时调用(按照它们定义的顺序)，并且在main方法之前调用。它用于有条件地初始化静态变量。

类似地，我们有实例初始化器块(又名iib)，它们在对象实例化时被调用，通常用于去重复构造函数逻辑。

初始化式和构造函数的执行顺序如下:

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

提交答案