第五章 初始化与清理(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.
*///:~