沙漠中的鱼

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()