我的问题是关于静态关键字的一个特殊用法。可以使用静态关键字覆盖不属于任何函数的类中的代码块。例如下面的代码编译:
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。但是,可以同时删除最终关键字和静态关键字并使其编译。
这两方面都让我感到困惑。我怎么能有一个不属于任何方法的代码段呢?如何调用它呢?一般来说,这种用法的目的是什么?或者更好的是,我可以在哪里找到相关的文档?
风浪!什么是静态初始化器?
静态初始化器是java类中的一个静态{}代码块,在构造函数或主方法被调用之前只运行一次。
好的!告诉我更多……
是一个代码块静态{…}在任何Java类中。并在类被调用时由虚拟机执行。
不支持返回语句。
不支持参数。
不支持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内部。
当开发人员使用初始化式块时,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
}
}
我希望开发人员能够理解我的例子。
带有静态修饰符的代码块表示类初始化式;如果没有静态修饰符,代码块就是一个实例初始化器。
类初始化器在装入类时(实际上是在解析类时,但这是一个技术术语)按照它们定义的顺序执行(自顶向下,就像简单的变量初始化器一样)。
实例初始化式按照类实例化时定义的顺序执行,即在构造函数代码执行之前,在超级构造函数调用之后。
如果你从int a中删除static,它就变成了一个实例变量,你不能从静态初始化块中访问它。这将导致编译失败,并报错“非静态变量a不能从静态上下文引用”。
如果你也从初始化程序块中删除了static,那么它就变成了实例初始化程序,因此int a在构造时就被初始化了。
这直接来自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.实例初始化器什么时候有用?
实例初始化式的使用很少,但在以下情况下,它仍然是实例变量初始化式的有用替代:
初始化程序代码必须处理异常
执行无法用实例变量初始化式表示的计算。
当然,这样的代码可以在构造函数中编写。但如果一个类有多个构造函数,则必须在每个构造函数中重复代码。
使用实例初始化式,只需编写一次代码,无论使用什么构造函数创建对象,它都将被执行。(我猜这只是一个概念,并不常用。)
实例初始化器有用的另一种情况是匿名内部类,它根本不能声明任何构造函数。(这是一个放置日志功能的好地方吗?)
感谢Derhein。
还要注意,实现接口[1]的匿名类没有构造函数。因此,在构造时需要实例初始化器来执行任何类型的表达式。