续《JAVA编程思想》学习备忘(第155页:Initialization & Cleanup)-5
Non-static instance initialization
Java 提供一种相似的语法,叫做实例初始化,用来为每个对象初始化非静态变量。
举例:
//:initialization/Mugs.java
// Java "Instance Initialization."
import static staticPrint.Print.print;
class Mug{
Mug(int marker){
print("Mug("+marker+")");
}
void f(int marker){
print("f("+marker+")");
}
}
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)");
}
public static void main(String[] args){
print("Inside main()");
new Mugs();
print("new Mugs() completed");
new Mugs(1);
print("new Mugs(1) completed");
}
}
输出结果:
Inside main()
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs completed
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs(int)
new Mugs(1) completed
你可以看到实例初始化从句:
{
mug1 = new Mug(1);
mug2 = new Mug(2);
print("mug1 & mug2 initialized");
}
实例初始化从句在构造方法之前执行。
Array initialization
An array is simply a sequence of either objects or primitives that are all the same type and are packaged together under one identifier name.Arrays are defined and used with the square-brackets indexing operator[].To define an array reference,you simply follow your type name with empty square brackets:
int[] a1;
You can also put the square brackets after the identifier to produce exactly the same meaning:
int a1[]
……要创建数组存储空间,你必须写一个初始化的表达式。对数组来说,可在你的代码任意处初始化,但你也可用一种特别的初始化表达式,它必须发生在数组创建之处。举例:
int[] a1 = {1,2,3,4,5};
也可这样付值:
int[] a2;
a2=a1;
举例:
//:initialization/ArrayOfPrimitives.java
import static staticPrint.Print.print;
public class ArrayOfPrimitives{
public static void main(String[] args){
int[] a1 = {1,2,3,4,5};
int[] a2;
a2 = a1;
for(int i = 0; i < a2.length; i++)
a2[i]=a2[i]+1;
for(int i = 0; i < a1.length; i++)
print("a1["+i+"]="+a1[i]);
}
}
输出结果:
a1[0]=2
a1[1]=3
a1[2]=4
a1[3]=5
a1[4]=6
你可以看到a2改变,a1显现。此为引用付值。
所有的数组有一个内在的成员,你可查询,但不可改变,告诉你数组中有多少元素,这个成员是length 。
当写程序时如果你不知道在你的数组中需要多少元素怎么办?你只需使用new来创建数组元素。这里,尽管new工作创建了一个原始数据数组(new不会创建一个非数组原始数据类型):
//:initialization/ArrayNew.java
//Creating arrays with new.
import java.util.*;
import static staticPrint.Print.print;
public class ArrayNew{
public static void main(String[] args){
int[] a;
Random rand = new Random(47);
a = new int[rand.nextInt(20)];
print("length of a = " + a.length);
print(Arrays.toString(a));
}
}
输出结果:
length of a = 18
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
程序输出结果显示原始数据类型数组元素被自动地初始化为“空”值。(对numerics和char,这是0,而对boolean,它是false)
当然,上例数组也可被定义和初始化在同样的陈述句:
int[] a = new int[rand.nextInt(20)];
如果你创建一个非原始数据数组,你创建一个对象数组,考虑包装类型Integer,它是一个类而不是一个原始数据类型:
//:initialization/ArrayClassObj.java
//Creating an array of nonprimitive objects.
import java.util.*;
import static staticPrint.Print.print;
public class ArrayClassObj{
public static void main(String[] args){
Random rand = new Random(47);
Integer[] a = new Integer[rand.nextInt(20)];
print("length of a = " + a.length);
for(int i = 0; i < a.length; i++)
a[i] = rand.nextInt(500);//Autoboxing
print(Arrays.toString(a));
}
}
输出结果:(样板)
length of a = 18
[55,193,361,461,429,368,200,22,207,288,128,51,89,309,278,498,361,20]
这里,即使new之后创建数组:
Integer[] a = new Integer[rand.nextInt(20)];
它仅为一个对象数组,而初始化没有完成直到对象自身被初始化通过创建一个新的Integer对象(此例中通过autoboxing):
a[i] = rand.nextInt(500);
如果你忘记创建对象,无论如何,当你尝试使用这个空数组位置你将得到一个运行异常。
它也可能初始化对象数组通过使用大括号包裹的列表,这里有两种形式:
//:initialization/ArrayInit.java
//Array initialization.
import java.util.*;
public class ArrayInit{
public static void main(String[] args){
Integer[] a = {
new Integer(1),
new Integer(2),
3,//Autoboxing
};
Integer[] b = new Integer[]{
new Integer(1),
new Integer(2),
3,//Autoboxing
};
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}
输出结果:
[1,2,3]
[1,2,3]
尽管第一种形式很有用,它有更多的限制,因为它仅能被在数组定义之处使用。你可以到处使用第二种和第三种形式,即使在一个被调用方法内。举一个例子:
//:initialization/DynamicArray.java
//Array initialization.
public class DynamicArray{
public static void main(String[] args){
Other.main(new String[]{"fiddle","de","dum"});
}
}
class Other{
public static void main(String[] args){
for(String s : args)
System.out.println(s + " ");
}
}
输出结果:
fidde de dum
(待续)