Java編程思想學習筆記——初始化與清理（二）

成員初始化

Java盡力保證：所有變量在使用前都能得到適當的初始化。

• 方法的局部變量：未初始化，編譯錯誤。

void f(){
        int i;
//        System.out.println(i);//編譯錯誤
    }

• 類的數據成員（字段）是基本類型：保證都會有一個初始值。

public class InitialValues {
    boolean bl;
    char c;
    byte bt;
    short s;
    int i;
    long l;
    float f;
    double d;
    InitialValues reference;
    void printValues(){
        System.out.printf(
                "\nboolean:"+bl
                +"\nchar:"+c
                +"\nbyte:"+bt
                +"\nshort:"+s        
                +"\nint:"+i
                +"\nlong:"+l
                +"\nfloat:"+f
                +"\ndouble:"+d
                +"\nreference:"+reference
        );
    }

    public static void main(String[] args) {
        new InitialValues().printValues();
    }
}

結果輸出：

boolean:false
char:
byte:0
int:0
long:0
float:0.0
double:0.0
reference:null

• 指定初始化

在定義類成員變量的地方為變量賦值

public class InitialValues {
    boolean bl=true;
    char c='a';
    byte bt=22;
    short s=0xff;
    int i=1202;
    long l=1;
    float f=3.14f;
    double d=3.14159;
}

同樣的方式初始化非基本類型的對象

class Apple{}
public class InitialValues {
    Apple apple = new Apple();
}

調用方法來初始值

    int i1 = getIntValue();
    int i2 = getDoubleValue(2);

    private int getDoubleValue(int i) {
        return i*2;
    }

    private int getIntValue() {
        return 2;
    }

構造器初始化

無法阻止自動初始化的進行，它將在構造器被調用之前發生。

public class ConstructorInitial {
    int i ;
    ConstructorInitial(){
        System.out.println(i);
        i=1;
        System.out.println(i);
    }

    public static void main(String[] args) {
        new ConstructorInitial();
    }
}

結果：

0
1

初始化順序
在類的內部，變量定義的先後順序決定了初始化的順序。

靜態數據的初始化
無論創建多少個對象，靜態數據都只占用一份存儲區域。
靜態初始化只有在必要的時候才會進行。
初始化順序是：靜態對象－－>非靜態對象。

對象創建的過程
假設有個名為Dog的類：

1. 首次創建Dog對象（構造器可以看成靜態方法）或首次訪問Dog類的靜態方法或靜態域時，Java解釋器必須查找類路徑，以定位Dog.class文件。
2. 然後載入Dog.class（這將創建一個Class對象），有關靜態初始化的所有動作都會執行。因此，靜態初始化只有在Class對象首次加載的時候進行一次。
3. 當用new Dog()創建對象的時候，首先在堆上為Dog對象分配足夠的存儲空間。
4. 這塊存儲空間會被清零，這就自動地將Dog對象中的所有基本類型數據都設置成了默認值（數字為0，布爾型，字符型類似），而引用被設置為null。
5. 執行所有出現於字段定義處的初始化動作。
6. 執行構造器。

顯示的靜態初始化
Java允許將多個靜態初始化動作組織成一個特殊的"靜態塊"

class Cup{
    Cup(int marker){
        System.out.println("Cup("+marker+")");
    }
    void f(int marker){
        System.out.println("f("+marker+")");
    }
}
class Cups{
    //靜態成員變量
    static Cup cup1;
    static Cup cup2;
    //顯式的靜態初始化
    //靜態塊
    static {
        System.out.println("static initialization");
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups(){
        System.out.println("Cups()");
    }
}
public class Initialization {
    public static void main(String[] args) {
        Cups.cup1.f(100);
        /**
         *static initialization
         Cup(1)
         Cup(2)
         f(100)
         */
    }
//    static Cups cups = new Cups();
    /**
     * static initialization
     Cup(1)
     Cup(2)
     Cups()
     */
}

非靜態實例初始化
實例初始化：用於初始化每一個對象的非靜態變量。

class Cup{
    Cup(int marker){
        System.out.println("Cup("+marker+")");
    }
    void f(int marker){
        System.out.println("f("+marker+")");
    }
}
class Cups{
    //靜態成員變量
    static Cup cup1;
    static Cup cup2;
    Cup cup3,cup4;
    //顯式的靜態初始化
    //靜態塊
    static {
        System.out.println("static initialization");
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    //非靜態實例初��化
    {
        System.out.println("non-static initialization");
        cup3 = new Cup(3);
        cup4 = new Cup(4);
    }
    Cups(){
        System.out.println("Cups()");
    }
}
public class Initialization {
    public static void main(String[] args) {
        new Cups();
        /**
         *static initialization
         Cup(1)
         Cup(2)
         non-static initialization
         Cup(3)
         Cup(4)
         Cups()
         */
    }
}