网页功能: 加入收藏 设为首页 网站搜索  
Java编程思想(5)
发表日期:2003-06-04作者:[] 出处:  

第4章 初始化和清除

“随着计算机的进步,‘不安全’的程序设计已成为造成编程代价高昂的罪魁祸首之一。”

“初始化”和“清除”是这些安全问题的其中两个。许多C程序的错误都是由于程序员忘记初始化一个变量造成的。对于现成的库,若用户不知道如何初始化库的一个组件,就往往会出现这一类的错误。清除是另一个特殊的问题,因为用完一个元素后,由于不再关心,所以很容易把它忘记。这样一来,那个元素占用的资源会一直保留下去,极易产生资源(主要是内存)用尽的后果。

C++为我们引入了“构建器”的概念。这是一种特殊的方法,在一个对象创建之后自动调用。Java也沿用了这个概念,但新增了自己的“垃圾收集器”,能在资源不再需要的时候自动释放它们。本章将讨论初始化和清除的问题,以及Java如何提供它们的支持。

4.1 用构建器自动初始化

对于方法的创建,可将其想象成为自己写的每个类都调用一次initialize()。这个名字提醒我们在使用对象之前,应首先进行这样的调用。但不幸的是,这也意味着用户必须记住调用方法。在Java中,由于提供了名为“构建器”的一种特殊方法,所以类的设计者可担保每个对象都会得到正确的初始化。若某个类有一个构建器,那么在创建对象时,Java会自动调用那个构建器——甚至在用户毫不知觉的情况下。所以说这是可以担保的!

接着的一个问题是如何命名这个方法。存在两方面的问题。第一个是我们使用的任何名字都可能与打算为某个类成员使用的名字冲突。第二是由于编译器的责任是调用构建器,所以它必须知道要调用是哪个方法。C++采取的方案看来是最简单的,且更有逻辑性,所以也在Java里得到了应用:构建器的名字与类名相同。这样一来,可保证象这样的一个方法会在初始化期间自动调用。

下面是带有构建器的一个简单的类(若执行这个程序有问题,请参考第3章的“赋值”小节)。

//: SimpleConstructor.java

// Demonstration of a simple constructor

package c04;

class Rock {

 Rock() { // This is the constructor

  System.out.println("Creating Rock");

 }

}

public class SimpleConstructor {

 public static void main(String[] args) {

  for(int i = 0; i < 10; i++)

   new Rock();

 }

} ///:~

现在,一旦创建一个对象:

new Rock();

就会分配相应的存储空间,并调用构建器。这样可保证在我们经手之前,对象得到正确的初始化。

请注意所有方法首字母小写的编码规则并不适用于构建器。这是由于构建器的名字必须与类名完全相同!

和其他任何方法一样,构建器也能使用自变量,以便我们指定对象的具体创建方式。可非常方便地改动上述例子,以便构建器使用自己的自变量。如下所示:

class Rock {

 Rock(int i) {

  System.out.println(

   "Creating Rock number " + i);

 }

}

public class SimpleConstructor {

 public static void main(String[] args) {

  for(int i = 0; i < 10; i++)

   new Rock(i);

 }

}

利用构建器的自变量,我们可为一个对象的初始化设定相应的参数。举个例子来说,假设类Tree有一个构建器,它用一个整数自变量标记树的高度,那么就可以象下面这样创建一个Tree对象:

tree t = new Tree(12); // 12英尺高的树

若Tree(int)是我们唯一的构建器,那么编译器不会允许我们以其他任何方式创建一个Tree对象。

构建器有助于消除大量涉及类的问题,并使代码更易阅读。例如在前述的代码段中,我们并未看到对initialize()方法的明确调用——那些方法在概念上独立于定义内容。在Java中,定义和初始化属于统一的概念——两者缺一不可。

构建器属于一种较特殊的方法类型,因为它没有返回值。这与void返回值存在着明显的区别。对于void返回值,尽管方法本身不会自动返回什么,但仍然可以让它返回另一些东西。构建器则不同,它不仅什么也不会自动返回,而且根本不能有任何选择。若存在一个返回值,而且假设我们可以自行选择返回内容,那么编译器多少要知道如何对那个返回值作什么样的处理。

4.2 方法过载

在任何程序设计语言中,一项重要的特性就是名字的运用。我们创建一个对象时,会分配到一个保存区域的名字。方法名代表的是一种具体的行动。通过用名字描述自己的系统,可使自己的程序更易人们理解和修改。它非常象写散文——目的是与读者沟通。

我们用名字引用或描述所有对象与方法。若名字选得好,可使自己及其他人更易理解自己的代码。

将人类语言中存在细致差别的概念“映射”到一种程序设计语言中时,会出现一些特殊的问题。在日常生活中,我们用相同的词表达多种不同的含义——即词的“过载”。我们说“洗衬衫”、“洗车”以及“洗狗”。但若强制象下面这样说,就显得很愚蠢:“衬衫洗 衬衫”、“车洗 车”以及“狗洗 狗”。这是由于听众根本不需要对执行的行动作任何明确的区分。人类的大多数语言都具有很强的“冗余”性,所以即使漏掉了几个词,仍然可以推断出含义。我们不需要独一无二的标识符——可从具体的语境中推论出含义。

大多数程序设计语言(特别是C)要求我们为每个函数都设定一个独一无二的标识符。所以绝对不能用一个名为print()的函数来显示整数,再用另一个print()显示浮点数——每个函数都要求具备唯一的名字。

在Java里,另一项因素强迫方法名出现过载情况:构建器。由于构建器的名字由类名决定,所以只能有一个构建器名称。但假若我们想用多种方式创建一个对象呢?例如,假设我们想创建一个类,令其用标准方式进行初始化,另外从文件里读取信息来初始化。此时,我们需要两个构建器,一个没有自变量(默认构建器),另一个将字串作为自变量——用于初始化对象的那个文件的名字。由于都是构建器,所以它们必须有相同的名字,亦即类名。所以为了让相同的方法名伴随不同的自变量类型使用,“方法过载”是非常关键的一项措施。同时,尽管方法过载是构建器必需的,但它亦可应用于其他任何方法,且用法非常方便。

在下面这个例子里,我们向大家同时展示了过载构建器和过载的原始方法:

//: Overloading.java

// Demonstration of both constructor

// and ordinary method overloading.

import java.util.*;

class Tree {

 int height;

 Tree() {

  prt("Planting a seedling");

  height = 0;

 }

 Tree(int i) {

  prt("Creating new Tree that is "

    + i + " feet tall");

  height = i;

 }

 void info() {

  prt("Tree is " + height

    + " feet tall");

 }

 void info(String s) {

  prt(s + ": Tree is "

    + height + " feet tall");

 }

 static void prt(String s) {

  System.out.println(s);

 }

}

public class Overloading {

 public static void main(String[] args) {

  for(int i = 0; i < 5; i++) {

   Tree t = new Tree(i);

   t.info();

   t.info("overloaded method");

  }

  // Overloaded constructor:

  new Tree();

 }

} ///:~

Tree既可创建成一颗种子,不含任何自变量;亦可创建成生长在苗圃中的植物。为支持这种创建,共使用了两个构建器,一个没有自变量(我们把没有自变量的构建器称作“默认构建器”,注释①),另一个采用现成的高度。

①:在Sun公司出版的一些Java资料中,用简陋但很说明问题的词语称呼这类构建器——“无参数构建器”(no-arg constructors)。但“默认构建器”这个称呼已使用了许多年,所以我选择了它。

我们也有可能希望通过多种途径调用info()方法。例如,假设我们有一条额外的消息想显示出来,就使用String自变量;而假设没有其他话可说,就不使用。由于为显然相同的概念赋予了两个独立的名字,所以看起来可能有些古怪。幸运的是,方法过载允许我们为两者使用相同的名字。

4.2.1 区分过载方法

若方法有同样的名字,Java怎样知道我们指的哪一个方法呢?这里有一个简单的规则:每个过载的方法都必须采取独一无二的自变量类型列表。

若稍微思考几秒钟,就会想到这样一个问题:除根据自变量的类型,程序员如何区分两个同名方法的差异呢?

即使自变量的顺序也足够我们区分两个方法(尽管我们通常不愿意采用这种方法,因为它会产生难以维护的代码):

//: OverloadingOrder.java

// Overloading based on the order of

// the arguments.

public class OverloadingOrder {

 static void print(String s, int i) {

  System.out.println(

   "String: " + s +

   ", int: " + i);

 }

 static void print(int i, String s) {

  System.out.println(

   "int: " + i +

   ", String: " + s);

 }

 public static void main(String[] args) {

  print("String first", 11);

  print(99, "Int first");

 }

} ///:~

两个print()方法有完全一致的自变量,但顺序不同,可据此区分它们。

4.2.2 主类型的过载

主(数据)类型能从一个“较小”的类型自动转变成一个“较大”的类型。涉及过载问题时,这会稍微造成一些混乱。下面这个例子揭示了将主类型传递给过载的方法时发生的情况:

//: PrimitiveOverloading.java

// Promotion of primitives and overloading

public class PrimitiveOverloading {

 // boolean can't be automatically converted

 static void prt(String s) {

  System.out.println(s);

 }

 void f1(char x) { prt("f1(char)"); }

 void f1(byte x) { prt("f1(byte)"); }

 void f1(short x) { prt("f1(short)"); }

 void f1(int x) { prt("f1(int)"); }

 void f1(long x) { prt("f1(long)"); }

 void f1(float x) { prt("f1(float)"); }

 void f1(double x) { prt("f1(double)"); }

 void f2(byte x) { prt("f2(byte)"); }

 void f2(short x) { prt("f2(short)"); }

 void f2(int x) { prt("f2(int)"); }

 void f2(long x) { prt("f2(long)"); }

 void f2(float x) { prt("f2(float)"); }

 void f2(double x) { prt("f2(double)"); }

 void f3(short x) { prt("f3(short)"); }

 void f3(int x) { prt("f3(int)"); }

 void f3(long x) { prt("f3(long)"); }

 void f3(float x) { prt("f3(float)"); }

 void f3(double x) { prt("f3(double)"); }

 void f4(int x) { prt("f4(int)"); }

 void f4(long x) { prt("f4(long)"); }

 void f4(float x) { prt("f4(float)"); }

 void f4(double x) { prt("f4(double)"); }

 void f5(long x) { prt("f5(long)"); }

 void f5(float x) { prt("f5(float)"); }

 void f5(double x) { prt("f5(double)"); }

 void f6(float x) { prt("f6(float)"); }

 void f6(double x) { prt("f6(double)"); }

 void f7(double x) { prt("f7(double)"); }

 void testConstVal() {

  prt("Testing with 5");

  f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);

 }

 void testChar() {

  char x = 'x';

  prt("char argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testByte() {

  byte x = 0;

  prt("byte argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testShort() {

  short x = 0;

  prt("short argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testInt() {

  int x = 0;

  prt("int argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testLong() {

  long x = 0;

  prt("long argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testFloat() {

  float x = 0;

  prt("float argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 void testDouble() {

  double x = 0;

  prt("double argument:");

  f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);

 }

 public static void main(String[] args) {

  PrimitiveOverloading p =

   new PrimitiveOverloading();

  p.testConstVal();

  p.testChar();

  p.testByte();

  p.testShort();

  p.testInt();

  p.testLong();

  p.testFloat();

  p.testDouble();

 }

} ///:~

若观察这个程序的输出,就会发现常数值5被当作一个int值处理。所以假若可以使用一个过载的方法,就能获取它使用的int值。在其他所有情况下,若我们的数据类型“小于”方法中使用的自变量,就会对那种数据类型进行“转型”处理。char获得的效果稍有些不同,这是由于假期它没有发现一个准确的char匹配,就会转型为int。

若我们的自变量“大于”过载方法期望的自变量,这时又会出现什么情况呢?对前述程序的一个修改揭示出了答案:

//: Demotion.java

// Demotion of primitives and overloading

public class Demotion {

 static void prt(String s) {

  System.out.println(s);

 }

 void f1(char x) { prt("f1(char)"); }

 void f1(byte x) { prt("f1(byte)"); }

 void f1(short x) { prt("f1(short)"); }

 void f1(int x) { prt("f1(int)"); }

 void f1(long x) { prt("f1(long)"); }

 void f1(float x) { prt("f1(float)"); }

 void f1(double x) { prt("f1(double)"); }

 void f2(char x) { prt("f2(char)"); }

 void f2(byte x) { prt("f2(byte)"); }

 void f2(short x) { prt("f2(short)"); }

 void f2(int x) { prt("f2(int)"); }

 void f2(long x) { prt("f2(long)"); }

 void f2(float x) { prt("f2(float)"); }

 void f3(char x) { prt("f3(char)"); }

 void f3(byte x) { prt("f3(byte)"); }

 void f3(short x) { prt("f3(short)"); }

 void f3(int x) { prt("f3(int)"); }

 void f3(long x) { prt("f3(long)"); }

 void f4(char x) { prt("f4(char)"); }

 void f4(byte x) { prt("f4(byte)"); }

 void f4(short x) { prt("f4(short)"); }

 void f4(int x) { prt("f4(int)"); }

 void f5(char x) { prt("f5(char)"); }

 void f5(byte x) { prt("f5(byte)"); }

 void f5(short x) { prt("f5(short)"); }

 void f6(char x) { prt("f6(char)"); }

 void f6(byte x) { prt("f6(byte)"); }

 void f7(char x) { prt("f7(char)"); }

 void testDouble() {

  double x = 0;

  prt("double argument:");

  f1(x);f2((float)x);f3((long)x);f4((int)x);

  f5((short)x);f6((byte)x);f7((char)x);

 }

 public static void main(String[] args) {

  Demotion p = new Demotion();

  p.testDouble();

 }

} ///:~

在这里,方法采用了容量更小、范围更窄的主类型值。若我们的自变量范围比它宽,就必须用括号中的类型名将其转为适当的类型。如果不这样做,编译器会报告出错。

大家可注意到这是一种“缩小转换”。也就是说,在造型或转型过程中可能丢失一些信息。这正是编译器强迫我们明确定义的原因——我们需明确表达想要转型的愿望。

4.2.3 返回值过载

我们很易对下面这些问题感到迷惑:为什么只有类名和方法自变量列出?为什么不根据返回值对方法加以区分?比如对下面这两个方法来说,虽然它们有同样的名字和自变量,但其实是很容易区分的:

void f() {}

int f() {}

若编译器可根据上下文(语境)明确判断出含义,比如在int x=f()中,那么这样做完全没有问题。然而,我们也可能调用一个方法,同时忽略返回值;我们通常把这称为“为它的副作用去调用一个方法”,因为我们关心的不是返回值,而是方法调用的其他效果。所以假如我们象下面这样调用方法:

f();

Java怎样判断f()的具体调用方式呢?而且别人如何识别并理解代码呢?由于存在这一类的问题,所以不能根据返回值类型来区分过载的方法。

4.2.4 默认构建器

正如早先指出的那样,默认构建器是没有自变量的。它们的作用是创建一个“空对象”。若创建一个没有构建器的类,则编译程序会帮我们自动创建一个默认构建器。例如:

//: DefaultConstructor.java

class Bird {

 int i;

}

public class DefaultConstructor {

 public static void main(String[] args) {

  Bird nc = new Bird(); // default!

 }

} ///:~

对于下面这一行:

new Bird();

它的作用是新建一个对象,并调用默认构建器——即使尚未明确定义一个象这样的构建器。若没有它,就没有方法可以调用,无法构建我们的对象。然而,如果已经定义了一个构建器(无论是否有自变量),编译程序都不会帮我们自动合成一个:

class Bush {

Bush(int i) {}

Bush(double d) {}

}

现在,假若使用下述代码:

new Bush();

编译程序就会报告自己找不到一个相符的构建器。就好象我们没有设置任何构建器,编译程序会说:“你看来似乎需要一个构建器,所以让我们给你制造一个吧。”但假如我们写了一个构建器,编译程序就会说:“啊,你已写了一个构建器,所以我知道你想干什么;如果你不放置一个默认的,是由于你打算省略它。”

4.2.5 this关键字

如果有两个同类型的对象,分别叫作a和b,那么您也许不知道如何为这两个对象同时调用一个f()方法:

class Banana { void f(int i) { /* ... */ } }

Banana a = new Banana(), b = new Banana();

a.f(1);

b.f(2);

若只有一个名叫f()的方法,它怎样才能知道自己是为a还是为b调用的呢?

为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”,编译器为我们完成了一些幕后工作。其中的秘密就是第一个自变量传递给方法f(),而且那个自变量是准备操作的那个对象的句柄。所以前述的两个方法调用就变成了下面这样的形式:

Banana.f(a,1);

Banana.f(b,2);

这是内部的表达形式,我们并不能这样书写表达式,并试图让编译器接受它。但是,通过它可理解幕后到底发生了什么事情。

假定我们在一个方法的内部,并希望获得当前对象的句柄。由于那个句柄是由编译器“秘密”传递的,所以没有标识符可用。然而,针对这一目的有个专用的关键字:this。this关键字(注意只能在方法内部使用)可为已调用了其方法的那个对象生成相应的句柄。可象对待其他任何对象句柄一样对待这个句柄。但要注意,假若准备从自己某个类的另一个方法内部调用一个类方法,就不必使用this。只需简单地调用那个方法即可。当前的this句柄会自动应用于其他方法。所以我们能使用下面这样的代码:

class Apricot {

void pick() { /* ... */ }

void pit() { pick(); /* ... */ }

}

在pit()内部,我们可以说this.pick(),但事实上无此必要。编译器能帮我们自动完成。this关键字只能用于那些特殊的类——需明确使用当前对象的句柄。例如,假若您希望将句柄返回给当前对象,那么它经常在return语句中使用。

//: Leaf.java

// Simple use of the "this" keyword

public class Leaf {

 private int i = 0;

 Leaf increment() {

  i++;

  return this;

 }

 void print() {

  System.out.println("i = " + i);

 }

 public static void main(String[] args) {

  Leaf x = new Leaf();

  x.increment().increment().increment().print();

 }

} ///:~

由于increment()通过this关键字返回当前对象的句柄,所以可以方便地对同一个对象执行多项操作。

1. 在构建器里调用构建器

若为一个类写了多个构建器,那么经常都需要在一个构建器里调用另一个构建器,以避免写重复的代码。可用this关键字做到这一点。

通常,当我们说this的时候,都是指“这个对象”或者“当前对象”。而且它本身会产生当前对象的一个句柄。在一个构建器中,若为其赋予一个自变量列表,那么this关键字会具有不同的含义:它会对与那个自变量列表相符的构建器进行明确的调用。这样一来,我们就可通过一条直接的途径来调用其他构建器。如下所示:

//: Flower.java

// Calling constructors with "this"

public class Flower {

 private int petalCount = 0;

 private String s = new String("null");

 Flower(int petals) {

  petalCount = petals;

  System.out.println(

   "Constructor w/ int arg only, petalCount= "

   + petalCount);

 }

 Flower(String ss) {

  System.out.println(

   "Constructor w/ String arg only, s=" + ss);

  s = ss;

 }

 Flower(String s, int petals) {

  this(petals);

//!  this(s); // Can't call two!

  this.s = s; // Another use of "this"

  System.out.println("String & int args");

 }

 Flower() {

  this("hi", 47);

  System.out.println(

   "default constructor (no args)");

 }

 void print() {

//!  this(11); // Not inside non-constructor!

  System.out.println(

   "petalCount = " + petalCount + " s = "+ s);

 }

 public static void main(String[] args) {

  Flower x = new Flower();

  x.print();

 }

} ///:~

其中,构建器Flower(String s,int petals)向我们揭示出这样一个问题:尽管可用this调用一个构建器,但不可调用两个。除此以外,构建器调用必须是我们做的第一件事情,否则会收到编译程序的报错信息。

这个例子也向大家展示了this的另一项用途。由于自变量s的名字以及成员数据s的名字是相同的,所以会出现混淆。为解决这个问题,可用this.s来引用成员数据。经常都会在Java代码里看到这种形式的应用,本书的大量地方也采用了这种做法。

在print()中,我们发现编译器不让我们从除了一个构建器之外的其他任何方法内部调用一个构建器。

2. static的含义

理解了this关键字后,我们可更完整地理解static(静态)方法的含义。它意味着一个特定的方法没有this。我们不可从一个static方法内部发出对非static方法的调用(注释②),尽管反过来说是可以的。而且在没有任何对象的前提下,我们可针对类本身发出对一个static方法的调用。事实上,那正是static方法最基本的意义。它就好象我们创建一个全局函数的等价物(在C语言中)。除了全局函数不允许在Java中使用以外,若将一个static方法置入一个类的内部,它就可以访问其他static方法以及static字段。

②:有可能发出这类调用的一种情况是我们将一个对象句柄传到static方法内部。随后,通过句柄(此时实际是this),我们可调用非static方法,并访问非static字段。但一般地,如果真的想要这样做,只要制作一个普通的、非static方法即可。

有些人抱怨static方法并不是“面向对象”的,因为它们具有全局函数的某些特点;利用static方法,我们不必向对象发送一条消息,因为不存在this。这可能是一个清楚的自变量,若您发现自己使用了大量静态方法,就应重新思考自己的策略。然而,static的概念是非常实用的,许多时候都需要用到它。所以至于它们是否真的“面向对象”,应该留给理论家去讨论。事实上,即使Smalltalk在自己的“类方法”里也有类似于static的东西。

4.3 清除:收尾和垃圾收集

程序员都知道“初始化”的重要性,但通常忘记清除的重要性。毕竟,谁需要来清除一个int呢?但是对于库来说,用完后简单地“释放”一个对象并非总是安全的。当然,Java可用垃圾收集器回收由不再使用的对象占据的内存。现在考虑一种非常特殊且不多见的情况。假定我们的对象分配了一个“特殊”内存区域,没有使用new。垃圾收集器只知道释放那些由new分配的内存,所以不知道如何释放对象的“特殊”内存。为解决这个问题,Java提供了一个名为finalize()的方法,可为我们的类定义它。在理想情况下,它的工作原理应该是这样的:一旦垃圾收集器准备好释放对象占用的存储空间,它首先调用finalize(),而且只有在下一次垃圾收集过程中,才会真正回收对象的内存。所以如果使用finalize(),就可以在垃圾收集期间进行一些重要的清除或清扫工作。

但也是一个潜在的编程陷阱,因为有些程序员(特别是在C++开发背景的)刚开始可能会错误认为它就是在C++中为“破坏器”(Destructor)使用的finalize()——破坏(清除)一个对象的时候,肯定会调用这个函数。但在这里有必要区分一下C++和Java的区别,因为C++的对象肯定会被清除(排开编程错误的因素),而Java对象并非肯定能作为垃圾被“收集”去。或者换句话说:

垃圾收集并不等于“破坏”!

若能时刻牢记这一点,踩到陷阱的可能性就会大大减少。它意味着在我们不再需要一个对象之前,有些行动是必须采取的,而且必须由自己来采取这些行动。Java并未提供“破坏器”或者类似的概念,所以必须创建一个原始的方法,用它来进行这种清除。例如,假设在对象创建过程中,它会将自己描绘到屏幕上。如果不从屏幕明确删除它的图像,那么它可能永远都不会被清除。若在finalize()里置入某种删除机制,那么假设对象被当作垃圾收掉了,图像首先会将自身从屏幕上移去。但若未被收掉,图像就会保留下来。所以要记住的第二个重点是:

我们的对象可能不会当作垃圾被收掉!

有时可能发现一个对象的存储空间永远都不会释放,因为自己的程序永远都接近于用光空间的临界点。若程序执行结束,而且垃圾收集器一直都没有释放我们创建的任何对象的存储空间,则随着程序的退出,那些资源会返回给操作系统。这是一件好事情,因为垃圾收集本身也要消耗一些开销。如永远都不用它,那么永远也不用支出这部分开销。

4.3.1 finalize()用途何在

此时,大家可能已相信了自己应该将finalize()作为一种常规用途的清除方法使用。它有什么好处呢?

要记住的第三个重点是:

垃圾收集只跟内存有关!

也就是说,垃圾收集器存在的唯一原因是为了回收程序不再使用的内存。所以对于与垃圾收集有关的任何活动来说,其中最值得注意的是finalize()方法,它们也必须同内存以及它的回收有关。

但这是否意味着假如对象包含了其他对象,finalize()就应该明确释放那些对象呢?答案是否定的——垃圾收集器会负责释放所有对象占据的内存,无论这些对象是如何创建的。它将对finalize()的需求限制到特殊的情况。在这种情况下,我们的对象可采用与创建对象时不同的方法分配一些存储空间。但大家或许会注意到,Java中的所有东西都是对象,所以这到底是怎么一回事呢?

之所以要使用finalize(),看起来似乎是由于有时需要采取与Java的普通方法不同的一种方法,通过分配内存来做一些具有C风格的事情。这主要可以通过“固有方法”来进行,它是从Java里调用非Java方法的一种方式(固有方法的问题在附录A讨论)。C和C++是目前唯一获得固有方法支持的语言。但由于它们能调用通过其他语言编写的子程序,所以能够有效地调用任何东西。在非Java代码内部,也许能调用C的malloc()系列函数,用它分配存储空间。而且除非调用了free(),否则存储空间不会得到释放,从而造成内存“漏洞”的出现。当然,free()是一个C和C++函数,所以我们需要在finalize()内部的一个固有方法中调用它。

读完上述文字后,大家或许已弄清楚了自己不必过多地使用finalize()。这个思想是正确的;它并不是进行普通清除工作的理想场所。那么,普通的清除工作应在何处进行呢?

4.3.2 必须执行清除

为清除一个对象,那个对象的用户必须在希望进行清除的地点调用一个清除方法。这听起来似乎很容易做到,但却与C++“破坏器”的概念稍有抵触。在C++中,所有对象都会破坏(清除)。或者换句话说,所有对象都“应该”破坏。若将C++对象创建成一个本地对象,比如在堆栈中创建(在Java中是不可能的),那么清除或破坏工作就会在“结束花括号”所代表的、创建这个对象的作用域的末尾进行。若对象是用new创建的(类似于Java),那么当程序员调用C++的delete命令时(Java没有这个命令),就会调用相应的破坏器。若程序员忘记了,那么永远不会调用破坏器,我们最终得到的将是一个内存“漏洞”,另外还包括对象的其他部分永远不会得到清除。

相反,Java不允许我们创建本地(局部)对象——无论如何都要使用new。但在Java中,没有“delete”命令来释放对象,因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场,我们可以说正是由于存在垃圾收集机制,所以Java没有破坏器。然而,随着以后学习的深入,就会知道垃圾收集器的存在并不能完全消除对破坏器的需要,或者说不能消除对破坏器代表的那种机制的需要(而且绝对不能直接调用finalize(),所以应尽量避免用它)。若希望执行除释放存储空间之外的其他某种形式的清除工作,仍然必须调用Java中的一个方法。它等价于C++的破坏器,只是没后者方便。

finalize()最有用处的地方之一是观察垃圾收集的过程。下面这个例子向大家展示了垃圾收集所经历的过程,并对前面的陈述进行了总结。

//: Garbage.java

// Demonstration of the garbage

// collector and finalization

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

 }

} ///:~

上面这个程序创建了许多Chair对象,而且在垃圾收集器开始运行后的某些时候,程序会停止创建Chair。由于垃圾收集器可能在任何时间运行,所以我们不能准确知道它在何时启动。因此,程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f,Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的,它调用于垃圾收集期间。

另两个static变量——created以及finalized——分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后,每个Chair都有它自己的(非static)int i,所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后,标记会设为true,最终结束Chair对象的创建过程。

所有这些都在main()的内部进行——在下面这个循环里:

while(!Chair.f) {

new Chair();

new String("To take up space");

}

大家可能会疑惑这个循环什么时候会停下来,因为内部没有任何改变Chair.f值的语句。然而,finalize()进程会改变这个值,直至最终对编号47的对象进行收尾处理。

每次循环过程中创建的String对象只是属于额外的垃圾,用于吸引垃圾收集器——一旦垃圾收集器对可用内存的容量感到“紧张不安”,就会开始关注它。

运行这个程序的时候,提供了一个命令行自变量“before”或者“after”。其中,“before”自变量会调用System.gc()方法(强制执行垃圾收集器),同时还会调用System.runFinalization()方法,以便进行收尾工作。这些方法都可在Java 1.0中使用,但通过使用“after”自变量而调用的runFinalizersOnExit()方法却只有Java 1.1及后续版本提供了对它的支持(注释③)。注意可在程序执行的任何时候调用这个方法,而且收尾程序的执行与垃圾收集器是否运行是无关的。

③:不幸的是,Java 1.0采用的垃圾收集器方案永远不能正确地调用finalize()。因此,finalize()方法(特别是那些用于关闭文件的)事实上经常都不会得到调用。现在有些文章声称所有收尾模块都会在程序退出的时候得到调用——即使到程序中止的时候,垃圾收集器仍未针对那些对象采取行动。这并不是真实的情况,所以我们根本不能指望finalize()能为所有对象而调用。特别地,finalize()在Java 1.0里几乎毫无用处。

前面的程序向我们揭示出:在Java 1.1中,收尾模块肯定会运行这一许诺已成为现实——但前提是我们明确地强制它采取这一操作。若使用一个不是“before”或“after”的自变量(如“none”),那么两个收尾工作都不会进行,而且我们会得到象下面这样的输出:

Created 47

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!

因此,到程序结束的时候,并非所有收尾模块都会得到调用(注释④)。为强制进行收尾工作,可先调用System.gc(),再调用System.runFinalization()。这样可清除到目前为止没有使用的所有对象。这样做一个稍显奇怪的地方是在调用runFinalization()之前调用gc(),这看起来似乎与Sun公司的文档说明有些抵触,它宣称首先运行收尾模块,再释放存储空间。然而,若在这里首先调用runFinalization(),再调用gc(),收尾模块根本不会执行。

④:到你读到本书时,有些Java虚拟机(JVM)可能已开始表现出不同的行为。

针对所有对象,Java 1.1有时之所以会默认为跳过收尾工作,是由于它认为这样做的开销太大。不管用哪种方法强制进行垃圾收集,都可能注意到比没有额外收尾工作时较长的时间延迟。

4.4 成员初始化

Java尽自己的全力保证所有变量都能在使用前得到正确的初始化。若被定义成相对于一个方法的“局部”变量,这一保证就通过编译期的出错提示表现出来。因此,如果使用下述代码:

void f() {

int i;

i++;

}

就会收到一条出错提示消息,告诉你i可能尚未初始化。当然,编译器也可为i赋予一个默认值,但它看起来更象一个程序员的失误,此时默认值反而会“帮倒忙”。若强迫程序员提供一个初始值,就往往能够帮他/她纠出程序里的“臭虫”。

然而,若将基本类型(主类型)设为一个类的数据成员,情况就会变得稍微有些不同。由于任何方法都可以初始化或使用那个数据,所以在正式使用数据前,若还是强迫程序员将其初始化成一个适当的值,就可能不是一种实际的做法。然而,若为其赋予一个垃圾值,同样是非常不安全的。因此,一个类的所有基本类型数据成员都会保证获得一个初始值。可用下面这段小程序看到这些值:

//: InitialValues.java

// Shows default initial values

class Measurement {

 boolean t;

 char c;

 byte b;

 short s;

 int i;

 long l;

 float f;

 double d;

 void print() {

  System.out.println(

   "Data type   Inital value\n" +

   "boolean    " + t + "\n" +

   "char      " + c + "\n" +

   "byte      " + b + "\n" +

   "short     " + s + "\n" +

   "int      " + i + "\n" +

   "long      " + l + "\n" +

   "float     " + f + "\n" +

   "double     " + d);

 }

}

public class InitialValues {

 public static void main(String[] args) {

  Measurement d = new Measurement();

  d.print();

  /* In this case you could also say:

  new Measurement().print();

  */

我来说两句】 【加入收藏】 【返加顶部】 【打印本页】 【关闭窗口
中搜索 Java编程思想(5)
本类热点文章
  Java读取文件中含有中文的解决办法
  Java读取文件中含有中文的解决办法
  简单加密/解密方法包装, 含encode(),de..
  EJB 3.0规范全新体验
  java简单的获取windows系统网卡mac地址
  让Java程序带着JRE一起上路
  抢先体验"野马"J2SE6.0
  Java连接各种数据库的实例
  Java连接各种数据库的实例
  JAVA的XML编程实例解析
  Java学习从入门到精通(附FAQ)
  新手必读:Java学习的捷径
最新分类信息我要发布 
最新招聘信息

关于我们 / 合作推广 / 给我留言 / 版权举报 / 意见建议 / 广告投放  
Copyright ©2003-2024 Lihuasoft.net webmaster(at)lihuasoft.net
网站编程QQ群   京ICP备05001064号 页面生成时间:0.01668