靜態和非靜態初始化代碼塊有什么區別

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. 構造函數；