第五章 初始化與清理(2)

1.成員初始化

• Java盡力保證：所有變量在使用前都能得到恰當的初始化。
• 對于方法的局部變量，Java以編譯時錯誤的形式來貫徹這種保證。
• 對于類的成員變量：
  |Data type |Initial value|
  | :--- | :---: |
  |boolean |false|
  |char |值為0，輸出為空白|
  |byte |0|
  |short |0|
  |int |0|
  |long |0|
  |float |0.0|
  |double |0.0|
  |對象引用 |null|

2.定義時初始化

• 最直接的辦法：在定義類成員變量的地方為其賦值(在C++里不能這樣做)。
  • 上述方法同樣適用于非基本類型的對象，如下：

  class Depth{
    //...
  }

  public class Measurement{
    Depth d = new Depth();
    int i = f();
    int j = g(i);
    int f(){return 11;}
    int g(int n){return n*10;}
    //...
  }

注意：
1.若是沒有為d指定初始值就嘗試使用它，會出現運行時錯誤，產生異常。
2.也可以通過調用某個方法來提供初值。
3.上述初始化方法的限制：所定義類的每個對象都會具有相同的初值，不靈活。

3.構造器初始化

• 可以使用構造器進行初始化。在運行時，可以調用方法或執行某些動作來確定初值，這為編程帶來了更大的靈活性。

//: initialization/Counter.java
package initialization; /* Added by Eclipse.py */
public class Counter {
  int i;
  Counter() { i = 7; }
  // ...
} ///:~

注意:
無法阻止字段初始化的進行，它將在構造器被調用前發生。（上述，i首先被置為0，然后變成7。）對于所有基本類型和對象引用，包含定義時已經指定初值的變量，這種情況都成立。

• 對象創建的過程總結如下：
  
  

  對象創建過程
  
  注意:
  1.初始化的順序是先靜態對象（若它們尚未因前面的對象創建過程而被初始化），而后是"非靜態"對象。
  2.調用一個類的靜態方法或訪問一個類的靜態域，會導致其所有的靜態成員變量都會初始化（若它們尚未因前面的對象創建過程而被初始化），但是"非靜態"成員變量不會被創建（"非靜態"對象只有使用new操作時才會被創建）。
  3.調用一個類的靜態方法時，會先初始化所有靜態成員變量，再執行該靜態函數。

示例如下：

package io.github.wzzju;
import static io.github.wzzju.util.Print.*;

class Bowl {
  Bowl(int marker) {
    print("Bowl(" + marker + ")");
  }
}

public class StaticInitialization {
  public static void main(String[] args) {
    print("Creating new Bowl in main");
    new Bowl(66);
//    new StaticInitialization();
  }
  static Bowl bowl1 = new Bowl(1);
  Bowl bowl3 = new Bowl(33);
  static Bowl bowl2 = new Bowl(2);
}/*output:
Bowl(1)
Bowl(2)
Creating new Bowl in main
Bowl(66)
*/

程序運行時，先初始化bowl1，再初始化bowl2，而bowl3不會被初始化，因為程序啟動僅僅調用了靜態函數main，沒有使用new創建該類。最后執行main函數中的語句。將// new StaticInitialization();行的注釋去掉，運行結果如下：

/*output:
Bowl(1)
Bowl(2)
Creating new Bowl in main
Bowl(66)
Bowl(33)//bowl3被初始化
*/

從上述結果亦可以看出，若類中的靜態對象因前面的對象創建過程（或對靜態函數/靜態域的訪問過程）而被初始化，則不會被再次初始化。

• 顯示的靜態初始化
  靜態子句(靜態塊)如下：

//: initialization/Spoon.java
package initialization; /* Added by Eclipse.py */
public class Spoon {
  static int i;
  static double d;
  static {
    i = 47;
  d = 3.6;
  }
} ///:~

與其他靜態初始化動作一樣，這段代碼僅執行一次：當首次生成這個類的一個對象時，或者首次訪問屬于這個類的靜態數據成員時（即便從未生成過那個類的對象）。

• 非靜態實例初始化
  以下模式用于初始化每個對象的非靜態變量：

public class Mugs {
  Mug mug1;
  Mug mug2;
  {
    mug1 = new Mug(1);
    mug2 = new Mug(2);
    print("mug1 & mug2 initialized");
  }
  Mugs() {
    print("Mugs()");
  }
  Mugs(int i) {
    print("Mugs(int)");
  }
}

上述模式可以保證無論調用哪個顯示構造器，某些操作都會發生（{}內的初始化操作）。實例初始化子句是在構造器之前執行的。

4.數組初始化

• int[] a1;或int a1[];定義了一個數組的引用。在定義的時候不允許指定數組的大小。
• 對于數組，初始化動作可以出現在代碼的任何地方，但也可以使用一種特殊的初始化表達方式，它必須在創建數組的地方出現。如：int[] a1 = {1,2,3,4};。
• 數組元素下標從0開始，最大下標數是length-1。
• 在Java中，一旦對數組的訪問下標過界，就會出現運行時錯誤（即異常）。
• 可以直接用new在數組里創建元素。盡管創建的是基本類型數組。new仍然可以工作（不能用new創建單個的基本類型）。
• 如果可能，盡量在數組定義的同時進行初始化，如int[] a = new int[10];(第一種初始化方法，不靈活，只能用于定義處)。
  注意：使用第一種方法初始化之后，每個數組元素都被初始化為類型所對應的零值(若為非基本類型的數組，則每個數組元素值為null，此時要對每個數組元素使用new操作賦值)。
  第二種數組初始化方法：

Integer[] a = {
      new Integer(1),
      new Integer(2),
      3, // Autoboxing
    };

第三種初始化方法：

    Integer[] b = new Integer[]{
      new Integer(1),
      new Integer(2),
      3, // Autoboxing
    };

在第二、第三種初始化方法中，初始化列表的最后一個逗號都是可選的。

5.可變參數列表

形式如下：
static void print(Object... args){}
static void print(int required,String... args){}
示例代碼：

class A {}
public class NewVarArgs {
  static void printArray(Object... args) {
    for(Object obj : args)
      System.out.print(obj + " ");
    System.out.println();
  }
  public static void main(String[] args) {
    // Can take individual elements:
    printArray(new Integer(47), new Float(3.14),
      new Double(11.11));
    printArray(47, 3.14F, 11.11);
    printArray("one", "two", "three");
    printArray(new A(), new A(), new A());
    // Or an array:<1>
    printArray((Object[])new Integer[]{ 1, 2, 3, 4 });
    printArray(); // Empty list is OK
  }
} /* Output: (75% match)
47 3.14 11.11
47 3.14 11.11
one two three
A@1bab50a A@c3c749 A@150bd4d
1 2 3 4
*///:~

說明：

• 編譯器會將可變參數轉換為一個數組。所有在代碼中可以使用foreach來迭代可變參數。若傳遞來的實參已經是一個數組，則編譯器不會再執行轉換。若傳遞來的實參不只一個數組（兩個以上），則編譯器會將其轉換為數組的數組。
  在上例中，<1>處若換成printArray((Object[])new Integer[]{ 1, 2, 3, 4 },(Object[])new Integer[]{ 6, 7, 8, 9 });，則會對應輸出[Ljava.lang.Integer;@70dea4e [Ljava.lang.Integer;@5c647e05（輸出中[表示這是一個后面緊隨的類型的數組）。
• 在可變參數列表中可以使用任何類型的參數，包括基本類型。
  如：static void f(Character... args)、static void f(int... args)等。
• 作者的建議：可變參數列表使得重載變得很復雜，故而：我們應該總是只在重載方法的一個版本上使用可變參數列表，或在重載時壓根不使用它。

6.枚舉類型--enum

使用方法示例：

public enum Spiciness {
  NOT, MILD, MEDIUM, HOT, FLAMING
}
public class SimpleEnumUse {
  public static void main(String[] args) {
    Spiciness howHot = Spiciness.MEDIUM;
    System.out.println(howHot);
  }
} /* Output:
MEDIUM
*///:~

在創建enum時，編譯器會自動添加一些有用的特性，如，會創建toString()方法，以便可以方便的顯示某個enum實例的名稱，如上例輸出。編譯器還會創建ordinal()和static values()方法，使用如下：

public class EnumOrder {
  public static void main(String[] args) {
    for(Spiciness s : Spiciness.values())
      System.out.println(s + ", ordinal " + s.ordinal());
  }
} /* Output:
NOT, ordinal 0
MILD, ordinal 1
MEDIUM, ordinal 2
HOT, ordinal 3
FLAMING, ordinal 4
*///:~

ordinal():表示每個特定的enum常量的聲明順序，是一個整數。
static values():按照enum常量的聲明順序，產生由這些常量值構成的數組。

• enum的一個特別實用的特性，即可以在switch語句內使用：

public class Burrito {
  Spiciness degree;
  public Burrito(Spiciness degree) { this.degree = degree;}
  public void describe() {
    System.out.print("This burrito is ");
    switch(degree) {
      //不能寫成case Spiciness.NOT：...
    case NOT:    System.out.println("not spicy at all.");
                   break;
      case MILD:
      case MEDIUM: System.out.println("a little hot.");
                   break;
      case HOT:
      case FLAMING:
      default:     System.out.println("maybe too hot.");
    }
  } 
  public static void main(String[] args) {
    Burrito
      plain = new Burrito(Spiciness.NOT),
      greenChile = new Burrito(Spiciness.MEDIUM),
      jalapeno = new Burrito(Spiciness.HOT);
    plain.describe();
    greenChile.describe();
    jalapeno.describe();
  }
} /* Output:
This burrito is not spicy at all.
This burrito is a little hot.
This burrito is maybe too hot.
*///:~