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