沙漠中的魚

finalize()

工作原理應該是這樣的：一旦垃圾收集器準備好釋放對象占用的存儲空間，它首先調用finalize()，而且只有在下一次垃圾收集過程中，才會真正回收對象的內存。

為什么要使用finalize()方法

因為java內存回收之能回收自己java自己創建的對象，而對調用未java的對象，如C,C++創建的對象，不能自動的清除，可以通過在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 Garbage {
  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);
  }
} ///:~

輸入結果為：

Created 47
Beginning to finalize after 8694 Chairs have been created
Finalizing Chair #47, Setting flag to stop Chair creation
After all Chairs have been created:
total created = 9834, total finalized = 108
bye!

成員初使化

可以方法賦值初使化成員

下面這樣做是合法的：



class CInit {

int i = f();

int j = g(i);

//...

}



但下面這樣做是非法的：



class CInit {

int j = g(i);

int i = f();

//...

}

構造器初使化

class Counter {

int i;

Counter() { i = 7; }

i首先會初始化成零，然后變成7。

1.初使化順序

先初使化成員，然后執行構造器內容

2.靜態數據初使化

 
public class Dog {

    public static Dog sDog=new Dog("static dog");

    public Dog(String str){

        System.out.println(str);

    }

    public static void main(String[] args){

        Dog dog=new Dog("init");

    }

}

輸入出結果

static dog

init

(1) 類型為Dog的一個對象首次創建時，或者Dog類的static方法／static字段首次訪問時，Java解釋器必須找到Dog.class（在事先設好的類路徑里搜索）。
(2) 找到Dog.class后（它會創建一個Class對象，這將在后面學到），它的所有static初始化模塊都會運行。因此，static初始化僅發生一次——在Class對象首次載入的時候。
(3) 創建一個new Dog()時，Dog對象的構建進程首先會在內存堆（Heap）里為一個Dog對象分配足夠多的存儲空間。
(4) 這種存儲空間會清為零，將Dog中的所有基本類型設為它們的默認值（零用于數字，以及boolean和char的等價設定）。
(5) 進行字段定義時發生的所有初始化都會執行。
(6) 執行構建器。

3.明確進行的靜態初始化

class Spoon {  

   static int i;  

   static {    

     i = 47;  

   }

}

這段代碼僅執行一次——首次生成那個類的一個對象時，或者首次訪問屬于那個類的一個static成員時

4.非靜態實例的初始化

class Mug {

  Mug(int marker) {

    System.out.println("Mug(" + marker + ")");

  }

}



public class Mugs {

  Mug c1;

  {

    c1 = new Mug(1);

    System.out.println("c1 initialized");

  }

  Mugs() {

    System.out.println("Mugs()");

  }

  public static void main(String[] args) {

    System.out.println("Inside main()");

    Mugs x = new Mugs();

  }

}


輸入出結果

Inside main()

Mug(1)

c1 initialized

Mugs()