初始化和清除

用构建器自动初始化

构造函数不需要返回参数。在new一个对象的时候就调用构造函数来初始化一个对象。在没有定义构造函数的时候会有一个默认的构造函数。“在程序中什么时候调用哪个构造函数”？这个在下面详细说明。

方法过载

不同的方法用同一个名称，不过它们的参数必须不同。

public class test {
    public static void func(int a){
        System.out.println("int");
    }
    public static void func(long a){
        System.out.println("long");
    }
    public static void main(String[] args){
        func((short)1);
        func(1);
        func(1L);
    }
}

在上面的代码中如果输入的参数为“short”类型的，显然上面是没有完全匹配的方法，这是就需要“转型”处理。我想每种类型有固定的扩大其范围的路径，就沿着这个路径尝试，如果遇到有完全匹配方法就停止并调用这个方法。如果调用方法时候参数的范围比参数类型的范围还大，必须强制转化不然就会报错。

class A{
    int b;
    A(){
        this(1);
    }
    A(int a){
        //this(a);
        System.out.println(a++);        
    }
}
public class test {
    public static void main(String[] args){
        A t = new A(1); 
    }
}

构造函数中用“this（）”的时候必须在第一行的时候就写（想想为什么），并且不可能调用两个。这里需要理解一下“this指针”，然后也就理解了“static”类型的为什么不能访问普通类型中的普通方法了。

清除：收尾和垃圾回收

“垃圾收集器”只知道收集new分配的内存，这部分主要就是考虑一个方法：“finalize（）”。在Java中“垃圾收集器”的运行时间不能在程序中指定，当然finalize（）也不行（只有在内存不够的时候运行）。那finalize（）有什么作用呢？可以用它来观察“垃圾收集器”的工作过程。

class Chair {
    static boolean gcrun = false;
    static boolean f = false;
    static int created = 0;
    static int finalized = 0;
    int i;
    Chair() {
        i = ++created;
        if(created == 47)
            System.out.println("Created 47");
    }
    protected void finalize() {
        if(!gcrun) {
            gcrun = true;
            System.out.println("Beginning to finalize after "
                    +created + " Chairs have been created");
        }
        if(i == 47) {
            System.out.println(
                    "Finalizing Chair #47, " +
            "Setting flag to stop Chair creation");
            f = true;
        }
        finalized++;
        if(finalized >= created)
            System.out.println("All " + finalized + " finalized");
    }
}
public class test {
    public static void main(String[] args) {
        if(args.length == 0) {
            System.err.println("Usage: \n" +
                    "java Garbage before\n or:\n" +
                    "java Garbage after");
            return;
        }
        while(!Chair.f) {
            new Chair();
            new String("To take up space");
        }
        System.out.println(
                "After all Chairs have been created:\n" +
                "total created = " + Chair.created +
                ", total finalized = " + Chair.finalized);
        if(args[0].equals("before")) {
            System.out.println("gc():");
            System.gc();
            System.out.println("runFinalization():");
            System.runFinalization();
        }
        System.out.println("bye!");
        if(args[0].equals("after"))
            System.runFinalizersOnExit(true);
    }
}

成员初始化

这里需要注意的就是成员初始化的顺序。

在一个类中，初始化的顺序是由变量在类中定义的顺序决定的，变量会在调用任何方法之前得到初始化（包括构建器）。这应该是在给对象分配空间的时候顺便搞定的。如果是静态数据也一样。下面这个是一个不错的例子：

class Bowl {
    Bowl(int marker) {
        System.out.println("Bowl(" + marker + ")");
    }
    void f(int marker) {
        System.out.println("f(" + marker + ")");
    }
}
class Table {
    static Bowl b1 = new Bowl(1);
    Table() {
        System.out.println("Table()");
        b2.f(1);
    }
    void f2(int marker) {
        System.out.println("f2(" + marker + ")");
    }
    static Bowl b2 = new Bowl(2);
}
class Cupboard {
    Bowl b3 = new Bowl(3);
    static Bowl b4 = new Bowl(4);
    Cupboard() {
        System.out.println("Cupboard()");
        b4.f(2);
    }
    void f3(int marker) {
        System.out.println("f3(" + marker + ")");
    }
    static Bowl b5 = new Bowl(5);
}
public class test {
    public static void main(String[] args) {
        System.out.println(
            "Creating new Cupboard() in main");
        new Cupboard();
        System.out.println(
            "Creating new Cupboard() in main");
        new Cupboard();
        t2.f2(1);
        t3.f3(1);
    }
    static Table t2 = new Table();
    static Cupboard t3 = new Cupboard();
}

“static”的初始化只有在必要的时候才会进行，如果不创建对象，那就永远也不会被创建。在new之前“static”都值都会初始化，然后就是普通的值了。这些都可以通过上面的这个程序验证。

数组的初始化

这里的内容不如上面的有意思，数组也是一个对象，然后要注意的就是“多维数组”吧。

--------------------------------------------霸气的分割线--------------------------------------------

欢迎拍砖。