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

Question

我的问题是静态关键字的一个特定用法.可以使用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从初始化程序块中删除它,那么它将成为实例初始化程序,因此int a在构造时初始化.

Answer 2

UFF!什么是静态初始化程序？

静态初始化程序是static {}java类中的代码块,在调用构造函数或main方法之前只运行一次.

好!告诉我更多......

• 是static { ... }任何java类中的代码块.并在调用类时由虚拟机执行.
• 不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.");
    }
}

输出???

内部静态初始化器.

苹果

橙子

梨

结束静态初始化程序.

内部主要方法.

希望这可以帮助!

Answer 3

该static块是"静态初始化器".

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

我个人在编写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. 执行无法使用实例变量初始值设定项表达的计算.

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

使用实例初始化程序,您只需编写一次代码,无论使用何种构造函数创建对象,都将执行该代码.(我想这只是一个概念,并没有经常使用.)

实例初始化器有用的另一种情况是匿名内部类,它根本不能声明任何构造函数.(这是放置记录功能的好地方吗？)

感谢Derhein.

另请注意,实现接口[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 对象共享的一个，并且静态代码块仅在第一次加载 Test 类时初始化“a”一次，无论创建了多少个 Test 对象。