java担任和finalize()

通过“合成”要领建设新类时，永远不必担忧对谁人类的成员工具的收尾事情。每个成员都是一个独立的工具，所以会获得正常的垃圾收集以及收尾处理惩罚——无论它是不是不本身某个类一个成员。但在举办初始化的时候，必需包围衍生类中的finalize()要领——假如已经设计了某个非凡的排除历程，要求它必需作为垃圾收集的一部门举办。包围衍生类的finalize()时，务必记着挪用finalize()的基本类版本。不然，基本类的初始化基础不会产生。下面这个例子即是明证：

//: Frog.java
// Testing finalize with inheritance

class DoBaseFinalization {
  public static boolean flag = false;
}

class Characteristic {
  String s;
  Characteristic(String c) {
    s = c;
    System.out.println(
      "Creating Characteristic " + s);
  }
  protected void finalize() {
    System.out.println(
      "finalizing Characteristic " + s);
  }
}

class LivingCreature {
  Characteristic p = 
    new Characteristic("is alive");
  LivingCreature() {
    System.out.println("LivingCreature()");
  }
  protected void finalize() {
    System.out.println(
      "LivingCreature finalize");
    // Call base-class version LAST!
    if(DoBaseFinalization.flag)
      try {
        super.finalize();
      } catch(Throwable t) {}
  }
}

class Animal extends LivingCreature {
  Characteristic p = 
    new Characteristic("has heart");
  Animal() {
    System.out.println("Animal()");
  }
  protected void finalize() {
    System.out.println("Animal finalize");
    if(DoBaseFinalization.flag)
      try {
        super.finalize();
      } catch(Throwable t) {}
  }
}

class Amphibian extends Animal {
  Characteristic p = 
    new Characteristic("can live in water");
  Amphibian() {
    System.out.println("Amphibian()");
  }
  protected void finalize() {
    System.out.println("Amphibian finalize");
    if(DoBaseFinalization.flag)
      try {
        super.finalize();
      } catch(Throwable t) {}
  }
}

public class Frog extends Amphibian {
  Frog() {
    System.out.println("Frog()");
  }
  protected void finalize() {
    System.out.println("Frog finalize");
    if(DoBaseFinalization.flag)
      try {
        super.finalize();
      } catch(Throwable t) {}
  }
  public static void main(String[] args) {
    if(args.length != 0 && 
       args[0].equals("finalize"))
       DoBaseFinalization.flag = true;
    else
      System.out.println("not finalizing bases");
    new Frog(); // Instantly becomes garbage
    System.out.println("bye!");
    // Must do this to guarantee that all 
    // finalizers will be called:
    System.runFinalizersOnExit(true);
  }
} ///:~

DoBasefinalization类只是简朴地容纳了一个符号，向分级布局中的每个类指出是否应挪用super.finalize()。这个符号的配置成立在呼吁行参数的基本上，所以可以或许在举办和不举办基本类收尾事情的前提下查察行为。
分级布局中的每个类也包括了Characteristic类的一个成员工具。各人可以看到，无论是否挪用了基本类收尾模块，Characteristic成员工具都必定会获得收尾（排除）处理惩罚。
每个被包围的finalize()至少要拥有对protected成员的会见权力，因为Object类中的finalize()要领具有protected属性，而编译器不答允我们在担任进程中消除会见权限（“友好的”比“受到掩护的”具有更小的会见权限）。
在Frog.main()中，DoBaseFinalization符号会获得设置，并且会建设单唯一个Frog工具。请记着垃圾收集（出格是收尾事情）大概不会针对任何特定的工具产生，所觉得了强制采纳这一动作，System.runFinalizersOnExit(true)添加了特另外开销，以担保收尾事情的正常举办。若没有基本类初始化，则输出功效是：

not finalizing bases
Creating Characteristic is alive
LivingCreature()
Creating Characteristic has heart
Animal()
Creating Characteristic can live in water
Amphibian()
Frog()
bye!
Frog finalize
finalizing Characteristic is alive
finalizing Characteristic has heart
finalizing Characteristic can live in water

从中可以看出确实没有为基本类Frog挪用收尾模块。但如果在呼吁行插手“finalize”自变量，则会得到下述功效：

Creating Characteristic is alive
LivingCreature()
Creating Characteristic has heart
Animal()
Creating Characteristic can live in water
Amphibian()
Frog()
bye!
Frog finalize
Amphibian finalize
Animal finalize
LivingCreature finalize
finalizing Characteristic is alive
finalizing Characteristic has heart
finalizing Characteristic can live in water

#p#分页标题#e#

尽量成员工具凭据与它们建设时沟通的顺序举办收尾，但从技能角度说，并没有指定工具收尾的顺序。但对付基本类，我们可对收尾的顺序举办节制。回收的最佳顺序正是在这里回收的顺序，它与初始化顺序正好相反。凭据与C++顶用于“粉碎器”沟通的形式，我们应该首先执行衍生类的收尾，再是基本类的收尾。这是由于衍生类的收尾大概挪用基本类中沟通的要领，要求基本类组件仍然处于勾当状态。因此，必需提前将它们排除（粉碎）。

当前位置：以往代写 > JAVA 教程 >java担任和finalize()