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

個人問題是關於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關鍵字並進行編譯。

這兩種方式都使我感到困惑。 我應該如何擁有不屬於任何方法的代碼段？ 如何調用它？ 一般，此用法的目的是什麼？ 或者更好的是，在哪裏能夠找到有關此文件的文檔？

---

#1樓

當開發人員使用初始化程序塊時，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
    }
}

我但願開發人員能夠理解個人示例。

---

#2樓

ff！ 什麼是靜態初始值設定項？

靜態初始值設定項是java類內部的static {}代碼塊，而且在調用構造函數或main方法以前僅運行一次。

好！ 告訴我更多...

• 是任何Java類中的static { ... }代碼塊。 並在調用class時由虛擬機執行。
• 不支持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.");
    }
}

輸出???

內部靜態初始化器。

蘋果

橙子

梨

結束靜態初始化程序。

內部主要方法。

但願這能夠幫助！

---

#3樓

這直接來自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]的匿名類沒有構造函數。 所以，在構造時須要實例初始化程序來執行任何類型的表達式。

---

#4樓

static塊是「靜態初始化器」。

在加載類時會自動調用它，而且沒有其餘方法能夠調用它（甚至不能經過反射）。

我我的只在編寫JNI代碼時使用過它：

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

---

#5樓

靜態代碼塊可用於實例化或初始化類變量（與對象變量相反）。 所以，聲明「 a」靜態意味着全部測試對象僅共享一個，而且在首次加載Test類時，不管建立了多少個Test對象，靜態代碼塊僅將「 a」初始化一次。