1、0,3 初始化和清除,1,?,为什么要初始化对象？ 为什么不要清除对象？ 如何进行初始化？,2,由构建器保证初始化 方法过载 清除：收尾和垃圾收集 成员初始化 数组初始化,3,1.用构建器自动初始化,对于方法的创建，可将其想象成为自己写的每个类都调用一次initialize()。这个名字提醒我们在使用对象之前，应首先进行这样的调用。但不幸的是，这也意味着用户必须记住调用方法。在Java中，由于提供了名为“构建器”的一种特殊方法，所以类的设计者可担保每个对象都会得到正确的初始化。若某个类有一个构建器，那么在创建对象时，Java会自动调用那个构建器甚至在用户毫不知觉的情况下。 接着的一个问题是如何
2、命名这个方法。存在两方面的问题。第一个是我们使用的任何名字都可能与打算为某个类成员使用的名字冲突。第二是由于编译器的责任是调用构建器，所以它必须知道要调用是哪个方法。C+采取的方案看来是最简单的，且更有逻辑性，所以也在Java里得到了应用：构建器的名字与类名相同。这样一来，可保证象这样的一个方法会在初始化期间自动调用。,4,1.用构建器自动初始化,/ SimpleConstructor.java / Demonstration of a simple constructor.class Rock Rock() / This is the constructorSystem.out.printl
3、n(“Creating Rock“); ,5,1.用构建器自动初始化,public class SimpleConstructor public static void main(String args) for(int i = 0; i 10; i+)new Rock(); ,6,1.用构建器自动初始化,现在，一旦创建一个对象： new Rock(); 就会分配相应的存储空间，并调用构建器。这样可保证在我们经手之前，对象得到正确的初始化。 请注意所有方法首字母小写的编码规则并不适用于构建器。这是由于构建器的名字必须与类名完全相同！ 和其他任何方法一样，构建器也能使用自变量，以便我们指定对象的
4、具体创建方式。可非常方便地改动上述例子，以便构建器使用自己的自变量。如下所示：,7,1.用构建器自动初始化,/ SimpleConstructor2.java / Constructors can have arguments.class Rock2 Rock2(int i) System.out.println(“Creating Rock number “ + i); ,8,1.用构建器自动初始化,public class SimpleConstructor2 public static void main(String args) for(int i = 0; i 10; i+)new
5、Rock2(i); ,9,1.用构建器自动初始化,利用构建器的自变量，我们可为一个对象的初始化设定相应的参数。 举个例子来说，假设类Tree有一个构建器，它用一个整数自变量标记树的高度，那么就可以象下面这样创建一个Tree对象： Tree t = new Tree(12); / 12英尺高的树 若Tree(int)是我们唯一的构建器，那么编译器不会允许我们以其他任何方式创建一个Tree对象。,10,1.用构建器自动初始化,构建器有助于消除大量涉及类的问题，并使代码更易阅读。例如在前述的代码段中，我们并未看到对initialize()方法的明确调用那些方法在概念上独立于定义内容。在Java中，定
6、义和初始化属于统一的概念两者缺一不可。 构建器属于一种较特殊的方法类型，因为它没有返回值。这与void返回值存在着明显的区别。对于void返回值，尽管方法本身不会自动返回什么，但仍然可以让它返回另一些东西。构建器则不同，它不仅什么也不会自动返回，而且根本不能有任何选择。若存在一个返回值，而且假设我们可以自行选择返回内容，那么编译器多少要知道如何对那个返回值作什么样的处理。,11,2.方法过载,在任何程序设计语言中，一项重要的特性就是名字的运用。我们创建一个对象时，会分配到一个保存区域的名字。方法名代表的是一种具体的行动。通过用名字描述自己的系统，可使自己的程序更易人们理解和修改。它非常象写散文
7、目的是与读者沟通。 我们用名字引用或描述所有对象与方法。若名字选得好，可使自己及其他人更易理解自己的代码。,12,2.方法过载,将人类语言中存在细致差别的概念“映射”到一种程序设计语言中时，会出现一些特殊的问题。在日常生活中，我们用相同的词表达多种不同的含义即词的“过载”。我们说“洗衬衫”、“洗车”以及“洗狗”。但若强制象下面这样说，就显得很愚蠢：“衬衫 洗 衬衫”、“车 洗 车”以及“狗 洗 狗”。这是由于听众根本不需要对执行的行动作任何明确的区分。人类的大多数语言都具有很强的“冗余”性，所以即使漏掉了几个词，仍然可以推断出含义。我们不需要独一无二的标识符可从具体的语境中推论出含义。 大多数
8、程序设计语言（特别是C）要求我们为每个函数都设定一个独一无二的标识符。所以绝对不能用一个名为print()的函数来显示整数，再用另一个print()显示浮点数每个函数都要求具备唯一的名字。,13,2.方法过载,在Java里，另一项因素强迫方法名出现过载情况：构建器。由于构建器的名字由类名决定，所以只能有一个构建器名称。但假若我们想用多种方式创建一个对象呢？例如，假设我们想创建一个类，令其用标准方式进行初始化，另外从文件里读取信息来初始化。此时，我们需要两个构建器，一个没有自变量（默认构建器），另一个将字串作为自变量用于初始化对象的那个文件的名字。由于都是构建器，所以它们必须有相同的名字，亦即类
9、名。所以为了让相同的方法名伴随不同的自变量类型使用，“方法过载”是非常关键的一项措施。同时，尽管方法过载是构建器必需的，但它亦可应用于其他任何方法，且用法非常方便。,14,2.方法过载,过载构建器和过载的原始方法： /: c04:Overloading.java / Demonstration of both constructor / and ordinary method overloading. import java.util.*;class Tree int height;Tree() System.out.println(“Planting a seedling“);height
10、= 0;,15,2.方法过载,Tree(int i) System.out.println(“Creating new Tree that is “+ i + “ feet tall“);height = i;void info() System.out.println(“Tree is “ + height + “ feet tall“);,16,2.方法过载,void info(String s) System.out.println(s + “: Tree is “+ height + “ feet tall“); ,17,2.方法过载,public class Overloading
11、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(); /:,18,2.方法过载,Tree既可创建成一颗种子，不含任何自变量；亦可创建成生长在苗圃中的植物。为支持这种创建，共使用了两个构建器，一个没有自变量（我们把没有自变量的构建器称作“默认构建器” ），另一个采用现成的高度。 我们也有可能希望通过多种途径调用info()方法。例如，假设我们
12、有一条额外的消息想显示出来，就使用String自变量；而假设没有其他话可说，就不使用。由于为显然相同的概念赋予了两个独立的名字，所以看起来可能有些古怪。但是，方法过载允许我们为两者使用相同的名字。,19,2.方法过载：区分过载方法,若方法有同样的名字，Java怎样知道我们指的哪一个方法呢？这里有一个简单的规则：每个过载的方法都必须采取独一无二的自变量类型列表。 若稍微思考几秒钟，就会想到这样一个问题：除根据自变量的类型，程序员如何区分两个同名方法的差异呢？ 自变量的顺序足够区分两个方法（通常不采用这种方法，因为它会产生难以维护的代码）： OverloadingOrder.java,20,2.方
13、法过载：主类型的过载,主（数据）类型能从一个“较小”的类型自动转变成一个“较大”的类型。涉及过载问题时，这会稍微造成一些混乱。下面这个例子揭示了将主类型传递给过载的方法时发生的情况： PrimitiveOverloading.java 若观察这个程序的输出，就会发现常数值5被当作一个int值处理。所以假若可以使用一个过载的方法，就能获取它使用的int值。在其他情况下，若我们的数据类型“小于”方法中使用的自变量，就会对那种数据类型进行“转型”处理。char获得的效果稍有些不同，这是由于它没有发现一个准确的char匹配，就会转型为int。,21,2.方法过载：主类型的过载,若我们的自变量“大于”过
14、载方法期望的自变量，这时又会出现什么情况呢？对前述程序的一个修改揭示出了答案： Demotion.java 在这里，方法采用了容量更小、范围更窄的主类型值。若自变量范围比它宽，就必须用括号中的类型名将其转为适当的类型。如果不这样做，编译器会报告出错。 大家可注意到这是一种“缩小转换”。也就是说，在造型或转型过程中可能丢失一些信息。这正是编译器强迫我们明确定义的原因我们需明确表达想要转型的愿望。,22,2.方法过载：返回值过载,很易对下面这些问题感到迷惑：为什么只有类名和方法自变量列出？为什么不根据返回值对方法加以区分？比如对下面这两个方法来说，虽然它们有同样的名字和自变量，但其实是很容易区分的
15、： void f() int f() 若编译器可根据上下文明确判断出含义，比如在int x=f()中，那么这样做完全没有问题。然而，也可能调用一个方法，同时忽略返回值；通常把这称为“为它的副作用去调用一个方法”，因为关心的不是返回值，而是方法调用的其他效果。所以假如象下面这样调用方法： f(); Java怎样判断f()的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能根据返回值类型来区分过载的方法。,?,23,2.方法过载：默认构建器,默认构建器是没有自变量的。它们的作用是创建一个“空对象”。若创建一个没有构建器的类，则编译程序会帮我们自动创建一个默认构建器。例如：
16、,24,2.方法过载：默认构建器,/: c04:DefaultConstructor.java class Bird int i; public class DefaultConstructor public static void main(String args) Bird nc = new Bird(); / Default! /:,25,2.方法过载：默认构建器,对于下面这一行： new Bird(); 它的作用是新建一个对象，并调用默认构建器即使尚未明确定义一个象这样的构建器。若没有它，就没有方法可以调用，无法构建对象。然而，如果已经定义了一个构建器（无论是否有自变量），编译程序都不
17、会帮我们自动合成一个： class Bush Bush(int i) Bush(double d) ,26,2.方法过载：默认构建器,现在，假若使用下述代码： new Bush(); 编译程序就会报告自己找不到一个相符的构建器。就好象我们没有设置任何构建器，编译程序会说：“你看来似乎需要一个构建器，所以让我们给你制造一个吧。”但假如我们写了一个构建器，编译程序就会说：“啊，你已写了一个构建器，所以我知道你想干什么；如果你不放置一个默认的，是由于你打算省略它。”,27,2.方法过载：this关键字,如果有两个同类型的对象，分别叫作a和b，那么您也许不知道如何为这两个对象同时调用一个f()方法：
18、class Banana void f(int i) /* . */ Banana a = new Banana(), b = new Banana(); a.f(1); b.f(2); 若只有一个名叫f()的方法，它怎样才能知道自己是为a还是为b调用的呢？,28,2.方法过载：this关键字,为了能用简便的、面向对象的语法来书写代码亦即“将消息发给对象”，编译器完成了一些幕后工作。其中的秘密就是第一个自变量传递给方法f()，而且那个自变量是准备操作的那个对象的句柄。所以前述的两个方法调用就变成了下面这样的形式： Banana.f(a,1); Banana.f(b,2); 这是内部的表达形式，
19、我们并不能这样书写表达式，并试图让编译器接受它。但是，通过它可理解幕后到底发生了什么事情。,29,2.方法过载：this关键字,假定我们在一个方法的内部，并希望获得当前对象的句柄。由于那个句柄是由编译器“秘密”传递的，所以没有标识符可用。 针对这一目的有个专用的关键字：this。this关键字（注意只能在方法内部使用）可为已调用了其方法的那个对象生成相应的句柄。可象对待其他任何对象句柄一样对待这个句柄。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法即可。当前的this句柄会自动应用于其他方法。所以我们能使用下面这样的代码：,30,2.方
20、法过载：this关键字,class Apricot void pick() /* . */ void pit() pick(); /* . */ 在pit()内部，我们可以说this.pick()，但事实上无此必要。编译器能自动完成。this关键字只能用于那些特殊的类需明确使用当前对象的句柄。例如，假若您希望将句柄返回给当前对象，那么它经常在return语句中使用。 Leaf.java,31,2.方法过载：this关键字 在构建器里调用构建器,若为一个类写了多个构建器，那么经常都需要在一个构建器里调用另一个构建器，以避免写重复的代码。可用this关键字做到这一点。 通常，当我们说this的时候
21、，都是指“这个对象”或者“当前对象”。而且它本身会产生当前对象的一个句柄。在一个构建器中，若为其赋予一个自变量列表，那么this关键字会具有不同的含义：它会对与那个自变量列表相符的构建器进行明确的调用。这样一来，就可通过一条直接的途径来调用其他构建器。 Flower.java,32,2.方法过载：this关键字 在构建器里调用构建器,其中，构建器Flower(String s,int petals)向我们揭示出这样一个问题：尽管可用this调用一个构建器，但不可调用两个。除此以外，构建器调用必须是我们做的第一件事情，否则会收到编译程序的报错信息。 这个例子也向大家展示了this的另一项用途。由
22、于自变量s的名字以及成员数据s的名字是相同的，所以会出现混淆。为解决这个问题，可用this.s来引用成员数据。经常都会在Java代码里看到这种形式的应用。 在print()中，我们发现编译器不让我们从除了一个构建器之外的其他任何方法内部调用一个构建器。,33,2.方法过载：this关键字 static的含义,理解了this关键字后，我们可更完整地理解static（静态）方法的含义。它意味着一个特定的方法没有this。不可从一个static方法内部发出对非static方法的调用，尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个static方法的调用。事实上，那正是st
23、atic方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C语言中）。除了全局函数不允许在Java中使用以外，若将一个static方法置入一个类的内部，它就可以访问其他static方法以及static字段。,34,2.方法过载：this关键字 static的含义,有人抱怨static方法并不是“面向对象”的，因为它们具有全局函数的某些特点；利用static方法，我们不必向对象发送一条消息，因为不存在this。这可能是一个清楚的自变量，若您发现自己使用了大量静态方法，就应重新思考自己的策略。然而，static的概念是非常实用的，许多时候都需要用到它。所以至于它们是否真的“面向对象”，应该
24、留给理论家去讨论。事实上，即使Smalltalk在自己的“类方法”里也有类似于static的东西。,35,3.清除：收尾和垃圾收集,程序员都知道“初始化”的重要性，但通常忘记清除的重要性。毕竟，谁需要来清除一个int呢？但是对于库来说，用完后简单地“释放”一个对象并非总是安全的。当然，Java可用垃圾收集器回收不再使用的对象占据的内存。现在考虑一种非常特殊且不多见的情况。 假定对象分配了一个“特殊”内存区域，没有使用new。垃圾收集器只知道释放那些由new分配的内存，所以不知道如何释放对象的“特殊”内存。为解决这个问题，Java提供了一个名为finalize()的方法。在理想情况下，它的工作原
25、理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。所以如果使用finalize()，就可以在垃圾收集期间进行一些重要的清除工作。,36,3.清除：收尾和垃圾收集,但也是一个潜在的编程陷阱，因为有些程序员（特别是在C+开发背景的）刚开始可能会错误认为它就是在C+中为“破坏器”（Destructor）使用的finalize()破坏（清除）一个对象的时候，肯定会调用这个函数。但在这里有必要区分一下C+和Java的区别，因为C+的对象肯定会被清除（排开编程错误的因素），而Java对象并非肯定能作为垃圾被“
26、收集”去。或者换句话说： 垃圾收集并不等于“破坏”！,37,3.清除：收尾和垃圾收集,若能时刻牢记这一点，踩到陷阱的可能性就会大大减少。它意味着在我们不再需要一个对象之前，有些行动是必须采取的，而且必须由自己来采取这些行动。Java并未提供“破坏器”或者类似的概念，所以必须创建一个原始的方法，用它来进行这种清除。例如，假设在对象创建过程中，它会将自己描绘到屏幕上。如果不从屏幕明确删除它的图像，那么它可能永远都不会被清除。若在finalize()里置入某种删除机制，那么假设对象被当作垃圾收掉了，图像首先会将自身从屏幕上移去。但若未被收掉，图像就会保留下来。所以要记住的第二个重点是： 对象可能不会
27、当作垃圾被收掉！,38,3.清除：收尾和垃圾收集,有时可能发现一个对象的存储空间永远都不会释放，因为自己的程序永远都接近于用光空间的临界点。若程序执行结束，而且垃圾收集器一直都没有释放我们创建的任何对象的存储空间，则随着程序的退出，那些资源会返回给操作系统。这是一件好事情，因为垃圾收集本身也要消耗一些开销。如永远都不用它，那么永远也不用支出这部分开销。,39,3.清除：finalize()用途何在,此时，大家可能已相信了自己应该将finalize()作为一种常规用途的清除方法使用。它有什么好处呢？ 要记住的第三个重点是： 垃圾收集只跟内存有关！ 也就是说，垃圾收集器存在的唯一原因是为了回收程序
28、不再使用的内存。所以对于与垃圾收集有关的任何活动来说，其中最值得注意的是finalize()方法，它们也必须同内存以及它的回收有关。,40,3.清除：finalize()用途何在,但这是否意味着假如对象包含了其他对象，finalize()就应该明确释放那些对象呢？答案是否定的垃圾收集器会负责释放所有对象占据的内存，不管这些对象是如何创建的。它将对finalize()的需求限制到特殊的情况。在这种情况下，我们的对象可采用与创建对象时不同的方法分配一些存储空间。但大家或许会注意到，Java中的所有东西都是对象，所以这到底是怎么一回事呢？,41,3.清除：finalize()用途何在,之所以要使用f
29、inalize()，看起来似乎是由于有时需要采取与Java的普通方法不同的一种方法，通过分配内存来做一些具有C风格的事情。这主要可以通过“Native方法”来进行，它是从Java里调用非Java方法的一种方式。C和C+是目前唯一获得Native方法支持的语言。但由于它们能调用通过其他语言编写的子程序，所以能够有效地调用任何东西。在非Java代码内部，能调用C的malloc()系列函数，用它分配存储空间。而且除非调用了free()，否则存储空间不会得到释放，从而造成内存“漏洞”的出现。当然，free()是一个C和C+函数，所以需要在finalize()内部的一个Native方法中调用它。 大家或
30、许已清楚了自己不必过多地使用finalize()。这个思想是正确的；它并不是进行普通清除工作的理想场所。那么，普通的清除工作应在何处进行呢？,42,3.清除：必须执行清除,为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这听起来似乎很容易做到，但却与C+“破坏器”的概念稍有抵触。在C+中，所有对象都会破坏（清除）。或者换句话说，所有对象都“应该”破坏。若将C+对象创建成一个本地对象，比如在堆栈中创建，那么清除或破坏工作就会在“结束花括号”所代表的、创建这个对象的作用域的末尾进行。若对象是用new创建的（类似于Java），那么当程序员调用C+的delete命令时（Java
31、没有这个命令），就会调用相应的破坏器。若程序员忘记了，那么永远不会调用破坏器，我们最终得到的将是一个内存“漏洞”，另外还包括对象的其他部分永远不会得到清除。,43,3.清除：必须执行清除,相反，Java不允许我们创建本地（局部）对象无论如何都要使用new。但在Java中，没有“delete”命令来释放对象，因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾收集机制，所以Java没有破坏器。然而，随着学习的深入，就会知道垃圾收集器的存在并不能完全消除对破坏器的需要，或者说不能消除对破坏器代表的那种机制的需要（而且绝对不能直接调用finalize()，
32、所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C+的破坏器，只是没后者方便。,44,3.清除：必须执行清除,finalize()最有用处的地方之一是观察垃圾收集的过程。下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结。 Garbage.java,45,3.清除：必须执行清除,这个程序创建了许多Chair对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始
33、运行。利用第二个标记f，Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的，它调用于垃圾收集期间。 另两个static变量created以及finalized分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个Chair都有它自己的（非static）int i，所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后，标记会设为true，最终结束Chair对象的创建过程。,46,3.清除：必须执行清除,所有这些都在main()的内部进行在下面这个循环里： while(!Chair.f) new Chair(
34、); new String(“To take up space“); 大家可能会疑惑这个循环什么时候会停下来，因为内部没有任何改变Chair.f值的语句。然而，finalize()进程会改变这个值，直至最终对编号47的对象进行收尾处理。,47,3.清除：必须执行清除,每次循环过程中创建的String对象只是属于额外的垃圾，用于吸引垃圾收集器一旦垃圾收集器对可用内存的容量感到“紧张不安”，就会开始关注它。 运行这个程序的时候，会调用System.gc()方法（强制执行垃圾收集器），同时还会调用System.runFinalization()方法，以便进行收尾工作。这些方法都可在Java 1.0中
35、使用，但通过调用的runFinalizersOnExit()方法却只有Java 1.1及后续版本提供了对它的支持。注意可在程序执行的任何时候调用这个方法，而且收尾程序的执行与垃圾收集器是否运行是无关的。,48,3.清除：垃圾收集的几点补充,（1）垃圾收集发生的不可预知性：由于实现了不同的垃圾收集算法和采用了不同的收集机制，所以它有可能是定时发生，有可能是当出现系统空闲CPU资源时发生，也有可能是和原始的垃圾收集一样，等到内存消耗出现极限时发生，这与垃圾收集器的选择和具体的设置都有关系。,49,3.清除：垃圾收集的几点补充,（2）垃圾收集的精确性：主要包括2 个方面：（a）垃圾收集器能够精确标记
36、活着的对象；（b）垃圾收集器能够精确地定位对象之间的引用关系。前者是完全地回收所有废弃对象的前提，否则就可能造成内存泄漏。而后者则是实现归并和复制等算法的必要条件。所有不可达对象都能够可靠地得到回收，所有对象都能够重新分配，允许对象的复制和对象内存的缩并，这样就有效地防止内存的支离破碎。,50,3.清除：垃圾收集的几点补充,（3）现在有许多种不同的垃圾收集器，每种有其算法且其表现各异，既有当垃圾收集开始时就停止应用程序的运行，又有当垃圾收集开始时也允许应用程序的线程运行，还有在同一时间垃圾收集多线程运行。 （4）垃圾收集的实现和具体的JVM 以及JVM的内存模型有非常紧密的关系。不同的JVM
37、可能采用不同的垃圾收集，而JVM 的内存模型决定着该JVM可以采用哪些类型垃圾收集。现在，HotSpot 系列JVM中的内存系统都采用先进的面向对象的框架设计，这使得该系列JVM都可以采用最先进的垃圾收集。,51,3.清除：垃圾收集的几点补充,（5）随着技术的发展，现代垃圾收集技术提供许多可选的垃圾收集器，而且在配置每种收集器的时候又可以设置不同的参数，这就使得根据不同的应用环境获得最优的应用性能成为可能。,52,3.清除：使用时注意事项,（1）不要试图去假定垃圾收集发生的时间，这一切都是未知的。比如，方法中的一个临时对象在方法调用完毕后就变成了无用对象，这个时候它的内存就可以被释放。 （2）
38、Java中提供了一些和垃圾收集打交道的类，而且提供了一种强行执行垃圾收集的方法-调用System.gc()，但这同样是个不确定的方法。Java 中并不保证每次调用该方法就一定能够启动垃圾收集，它只不过会向JVM发出这样一个申请，到底是否真正执行垃圾收集，一切都是个未知数。,53,3.清除：使用时注意事项,（3）挑选适合自己的垃圾收集器。一般来说，如果系统没有特殊和苛刻的性能要求，可以采用JVM的缺省选项。否则可以考虑使用有针对性的垃圾收集器，比如增量收集器就比较适合实时性要求较高的系统之中。系统具有较高的配置，有比较多的闲置资源，可以考虑使用并行标记/清除收集器。,54,3.清除：使用时注意事
39、项,（4）关键的也是难把握的问题是内存泄漏。良好的编程习惯和严谨的编程态度永远是最重要的，不要让自己的一个小错误导致内存出现大漏洞。 （5）尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域(scope)后，自动设置为null，暗示垃圾收集器来收集该对象，还必须注意该引用的对象是否被监听，如果有，则要去掉监听器，然后再赋空值。,55,4.成员初始化,Java尽自己的全力保证所有变量都能在使用前得到正确的初始化。若被定义成相对于一个方法的“局部”变量，这一保证就通过编译期的出错提示表现出来。因此，如果使用下述代码： void f() int i; i+; 就会收
40、到一条出错提示消息，告诉你i可能尚未初始化。当然，编译器也可为i赋予一个默认值，但它看起来更象一个程序员的失误，此时默认值反而会“帮倒忙”。若强迫程序员提供一个初始值，就往往能够帮助纠出程序里的“BUG”。,56,4.成员初始化,基本类型（主类型）为一个类的数据成员，情况就会变得稍微有些不同。由于任何方法都可以初始化或使用那个数据，所以在正式使用数据前，若还是强迫程序员将其初始化成一个适当的值，就可能不是一种实际的做法。然而，若为其赋予一个垃圾值，同样是非常不安全的。因此，一个类的所有基本类型数据成员都会保证获得一个初始值。可用下面这段小程序看到这些值： InitialValues.java
41、在一个类的内部定义一个对象句柄时，如果不将其初始化成新对象，那个句柄就会获得一个空值。,57,4.成员初始化:特定初始化,如果想自己为变量赋予一个初始值，又会发生什么情况呢？为达到这个目的，一个最直接的做法是在类内部定义变量的同时也为其赋值（注意在C+里不能这样做）。在下面，Measurement类内部的字段定义已发生了变化，提供了初始值： class Measurement boolean b = true; char c = x; byte B = 47; short s = 0xff; int i = 999; long l = 1; float f = 3.14f; double d
42、= 3.14159; /. . .,58,4.成员初始化:特定初始化,亦可用相同的方法初始化非基本（主）类型的对象。若Depth是一个类，那么可象下面这样插入一个变量并进行初始化： class Measurement Depth o = new Depth(); boolean b = true; / . . . 若尚未为o指定一个初始值，同时不顾一切地提前使用它，就会得到一条运行期错误提示，告诉你产生了名为“违例”（Exception）的一个错误。,59,4.成员初始化:特定初始化,甚至可通过调用一个方法来提供初始值： class CInit int i = f(); /. 当然，这个方法亦
43、可使用自变量，但那些自变量不能是尚未初始化的其他类成员。因此，下面这样做是合法的： class CInit int i = f(); int j = g(i); /. ,60,4.成员初始化:特定初始化,但下面这样做是非法的： class CInit int j = g(i); int i = f(); /. 这正是编译器对“向前引用”感到不适应的一个地方，因为它与初始化的顺序有关，而不是与程序的编译方式有关。 这种初始化方法非常简单和直观。它的一个限制是类型Measurement的每个对象都会获得相同的初始化值。有时，这正是我们希望的结果，但有时却需要盼望更大的灵活性。,61,4.成员初始化
44、:构建器初始化,可考虑用构建器执行初始化进程。这样便可在编程时获得更大的灵活程度，因为可以在运行期调用方法和采取行动，从而“现场”决定初始化值。但要注意：不可妨碍自动初始化的进行，它在构建器进入之前就会发生。因此，假如使用下述代码： class Counter int i; Counter() i = 7; / . . . 那么i首先会初始化成零，然后变成7。对于所有基本类型以及对象句柄，这种情况都是成立的，其中包括在定义时已进行了明确初始化的那些一些。考虑到这个原因，编译器不会试着强迫我们在构建器任何特定的场所对元素进行初始化，或者在它们使用之前初始化早已得到了保证。,62,4.成员初始化:
45、初始化顺序,在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化甚至在构建器调用之前。例如： OrderOfInitialization.java,63,4.成员初始化:静态数据的初始化,若数据是静态的（static），那么同样的事情就会发生；如果它属于一个基本类型（主类型），而且未对其初始化，就会自动获得自己的标准基本类型初始值；如果它是指向一个对象的句柄，那么除非新建一个对象，并将句柄同它连接起来，否则就会得到一个空值（NULL）。 如果想在定义的同时进行初始化，采取的方法与非静态值表面看起来是相同的。但由于
46、static值只有一个存储区域，所以无论创建多少个对象，都必然会遇到何时对那个存储区域进行初始化的问题。下面这个例子可将这个问题说更清楚一些： StaticInitialization.java,64,4.成员初始化:静态数据的初始化,static初始化只有在必要的时候才会进行。如果不创建一个Table对象，而且永远都不引用Table.b1或Table.b2，那么static Bowl b1和b2永远都不会创建。然而，只有在创建了第一个Table对象之后（或者发生了第一次static访问），它们才会创建。在那以后，static对象不会重新初始化。 初始化的顺序是首先static（如果它们尚未由
47、前一次对象创建过程初始化），接着是非static对象。大家可从输出结果中找到相应的证据。,65,4.成员初始化:静态数据的初始化,总结一下对象的创建过程。请考虑一个名为Dog的类： (1) 类型为Dog的一个对象首次创建时，或者Dog类的static方法static字段首次访问时，Java解释器必须找到Dog.class（在事先设好的类路径里搜索）。 (2) 找到Dog.class后（它会创建一个Class对象，这将在后面学到），它的所有static初始化模块都会运行。因此，static初始化仅发生一次在Class对象首次载入的时候。 (3) 创建一个new Dog()时，Dog对象的构建进程
48、首先会在内存堆（Heap）里为一个Dog对象分配足够多的存储空间。 (4) 这种存储空间会清为零，将Dog中的所有基本类型设为它们的默认值（零用于数字，以及boolean和char的等价设定）。 (5) 进行字段定义时发生的所有初始化都会执行。 (6) 执行构建器。,66,4.成员初始化:明确进行的静态初始化,Java允许将其他static初始化工作划分到类内一个特殊的“static构建从句”（有时也叫作“静态块”）里。它看起来象下面这个样子： class Spoon static int i; static i = 47; / . . .,67,4.成员初始化:明确进行的静态初始化,尽管看起
49、来象个方法，但它实际只是一个static关键字，后面跟随一个方法主体。与其他static初始化一样，这段代码仅执行一次首次生成那个类的一个对象时，或者首次访问属于那个类的一个static成员时（即便从未生成过那个类的对象）。例如： ExplicitStatic.java,68,4.成员初始化:非静态实例的初始化,针对每个对象的非静态变量的初始化，Java提供了一种类似的语法格式。下面是一个例子： Mugs.java 大家可看到实例初始化从句：c1 = new Mug(1);c2 = new Mug(2);System.out.println(“c1 ,69,5.数组初始化,数组代表一系列对象或者基本数据类型，所有相同的类型都封装到一起采用一个统一的标识符名称。数组的定义和使用是通过方括号索引运算符进行的（）。为定义一个数组，只需在类型名后简单地跟随一对空方括号即可： int al; 也可以将方括号置于标识符后面，获得完全一致的结果： int al; 这种格式与C和C+程序员习惯的格式是一致的。然而，最“通顺”的也许还是前一种语法，因为它指出类型是“一个int数组”。,
