0基础学习Java ——第五段 ---初始化与清理（下）

回忆一遥远

初始化与清理

---

---

---

成员初始化

---

---

非静态实例初始化
Java 中有类似实例初始化的语法吗，用来初始化，每一个对象的非静态变量。
例子：

class Mug{
        Mug(int mk){
                System.out.println("Mug(" + mk + ")");
        }
        void f(int mk) {
                System.out.println("f(" + mk + ")");
        }
}

public class Mugs {
        Mug mug1;
        Mug mug2;
        {
                mug1 = new Mug(1);
                mug2 = new Mug(2);
                System.out.println("mug1 & mug2 initialized");
        }
        Mugs(){
                System.out.println("Mugs()");
        }
        Mugs(int i){
                System.out.println("Mugs(int)");
        }
        public static void main(String[] args) {
                System.out.println("Inside main()");
                new Mugs();
                System.out.println("new Mugs() completed");
                new Mugs(1);
                System.out.println("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);
        System.out.println("mug1 & mug2 initialized");
}

看上去与静态初始化子句一摸一样，但少了 static 关键字。
这种语法对于支持“匿名内部类”的初始化是必须的，它也能让我们可以保证无论调用了哪个显式构造器，某些操作都会发生。



数组初始化

---

---

数组只是相同类型的、用一个标识符名称封装到一起的一个对象序列或基本类型数据序列。
数组是通过方括号下标操作符 [ ] 来定义和使用的。

数组定义方法：
        在类型名后加一对方括号：
                int[] a;
        方括号置于标识符后面：
                int a[];
以上两种格式的含义是一样的，后一种符合 C/C++ 的习惯。
前一种格式更加合理，因为它表明类型是“一个 int 型数组”。
编译器不允许指定数组的大小。
上面只是对数组的一个引用，没有给数组对象本身分配任何空间。为了给数组创建相应的存储空间，必须写初始化表达式，数组可以在任何地方进行初始化。
一种特殊的初始化表达式必须在创建数组时出现，它是由一对花括号和里面的值组成的。这种情况下，存储空间的内存分配（等价使用 new）将由编译器负责。
例如：
        int a = { 1, 2, 3, 4};
在 Java 中可以将一个数组赋值给另一个数组：
        int b;
        b = a;

事实上，这只是复制了一个引用：

public class ArraysOfPrimitives {

        public static void main(String[] args) {
                int[] a = {1, 2, 3, 4};
                int[] b;
                b = a;
                for(int i = 0; i < b.length; i++) {
                        b[i] = b[i] + 1;
                }
                for(int i = 0; i < a.length; i++) {
                        System.out.println("a[" + i + "] = " + a[i]);
                }
        }

}

输出：

a[0] = 2
a[1] = 3
a[2] = 4
a[3] = 5

由于 a 和 b 是相同数组的别名，因此对 b 的修改可以在 a 中看到。

所有数组都有一个固定成员 length ，他可以得知数组中包含多少元素，无法对其进行修改。
数组所能使用的最大下标是 length - 1 ，在 C/C++ 中，超过这个边界，它们会默默接受，而 Java 则能保护你免受数组越界的问题。

如果编写程序是不确定数组需要多少个元素，可以直接用 new 在数组中创建元素：

import java.util.*;
public class ArrayNew {

        public static void main(String[] args) {
                int[] a;
                Random rand = new Random();
                a = new int[rand.nextInt(20)];
                System.out.println("length of a = " + a.length);
                System.out.println(Arrays.toString(a));
        }

}

输出：

length of a = 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

输出表明：数组元素中的基本数据类型会自动初始化为空值。

Arrays.toString() 方法属于 java.util 标准类库，它会打印一维数组。

如果创建了一个非基本类型的数组，那么这就是一个引用数组。
以整形包装器 Integer 为例，它是一个类而不是基本类型：

import java.util.*;
public class ArrayClassObj {

        public static void main(String[] args) {
                Random rand = new Random();
                Integer[] a = new Integer[rand.nextInt(20)];
                System.out.println("length of a = " + a.length);
                for(int i = 0; i < a.length; i++) {
                        a[i] = rand.nextInt(500);
                }
                System.out.println(Arrays.toString(a));
        }

}

输出：

length of a = 6
[498, 394, 285, 480, 74, 298]

这里即使用 new 创建数组，它还只是一个引用数组。

可以用花括号括起来的列表来初始化对象数组（两种形式）：

import java.util.*;
public class ArrayInit {

        public static void main(String[] args) {
                Integer[] a = {
                                new Integer(1),
                                new Integer(2),
                                3,
                };
                Integer[] b = new Integer[]{
                                new Integer(1),
                                new Integer(2),
                                3,
                };
                System.out.println(Arrays.toString(a));
                System.out.println(Arrays.toString(b));
        }

}

输出：

[1, 2, 3]
[1, 2, 3]

这两种形式中，初始化列表最后一个逗号是可选的。
尽管第一种形式很有用，但它也更加受限——只能用于数组刚被定义处。


可变参数列表
Java SE5 之后，可以方便地定义可变参数列表了。
Java SE5 之前：

class A{}
public class VarArgs {
        static void printArray(Object[] args) {
                for(Object obj : args)
                        System.out.println(obj + " ");
                System.out.println();
        }
        public static void main(String[] args) {
                printArray(new Object[] {new Integer(47), new Float(3.14), new Double(11.11)});
                printArray(new Object[] {"one", "two", "three"});
                printArray(new Object[] {new A(), new A(), new A()});
        }

}

输出：

47 
3.14 
11.11 

one 
two 
three 

A@15db9742 
A@6d06d69c 
A@7852e922 

现在：

public class NewVarArgs {
        static void printArray(Object... args) {
                for(Object obj : args)
                        System.out.println(obj + " ");
                System.out.println();
        }
        public static void main(String[] args) {
                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());
                printArray((Object[])new Integer[] {1, 2, 3, 4});
                printArray();
        }

}

输出：

47 
3.14 
11.11 

47 
3.14 
11 
11 

one 
two 
three 

A@15db9742 
A@6d06d69c 
A@7852e922 

1 
2 
3 
4 

有了可变参数，就再也不用显式地编写数组语法了，当指定参数时，编译器会为你去填充数组。