Java编程思想第4版[中文版](PDF格式)-第155部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
Double，但在调用的时候必须用Double 传递。幸运的是，这个问题只存在于基本数据类型中间。
理解了具体的过程后，再来创建一个新对象，并且只为它提供一个Class 句柄，事情就变得非常简单了。就
目前的情况来说，内部循环中的return 永远不会执行，我们在终点就会退出。在这儿，程序动态装载 Class
对象，并把它加入 trashTypes （垃圾类型）列表，从而试图纠正这个问题。若仍然找不到真正有问题的地
方，同时装载又是成功的，那么就重复调用factory 方法，重新试一遍。
正如大家会看到的那样，这种设计方案最大的优点就是不需要改动代码。无论在什么情况下，它都能正常地
使用（假定所有Trash 子类都包含了一个构建器，用以获取单个 double 参数）。
1。 Trash 子类
为了与原型机制相适应，对Trash 每个新子类唯一的要求就是在其中包含了一个构建器，指示它获取一个
double 参数。Java 1。1 的“反射”机制可负责剩下的所有工作。
下面是不同类型的Trash，每种类型都有它们自己的文件里，但都属于 Trash 包的一部分（同样地，为了方
便在本章内重复使用）：
//： Aluminum。java
// The Aluminum class with prototyping
package c16。trash；
public class Aluminum extends Trash ｛
private static double val = 1。67f；
599
…………………………………………………………Page 601……………………………………………………………
public Aluminum（double wt） ｛ super（wt）； ｝
public double value（） ｛ return val； ｝
public static void value（double newVal） ｛
val = newVal；
｝
｝ ///：~
//： Paper。java
// The Paper class with prototyping
package c16。trash；
public class Paper extends Trash ｛
private static double val = 0。10f；
public Paper（double wt） ｛ super（wt）； ｝
public double value（） ｛ return val； ｝
public static void value（double newVal） ｛
val = newVal；
｝
｝ ///：~
//： Glass。java
// The Glass class with prototyping
package c16。trash；
public class Glass extends Trash ｛
private static double val = 0。23f；
public Glass（double wt） ｛ super（wt）； ｝
public double value（） ｛ return val； ｝
public static void value（double newVal） ｛
val = newVal；
｝
｝ ///：~
下面是一种新的Trash 类型：
//： Cardboard。java
// The Cardboard class with prototyping
package c16。trash；
public class Cardboard extends Trash ｛
private static double val = 0。23f；
public Cardboard（double wt） ｛ super（wt）； ｝
public double value（） ｛ return val； ｝
public static void value（double newVal） ｛
val = newVal；
｝
｝ ///：~
可以看出，除构建器以外，这些类根本没有什么特别的地方。
2。 从外部文件中解析出Trash
与Trash 对象有关的信息将从一个外部文件中读取。针对Trash 的每个方面，文件内列出了所有必要的信
息——每行都代表一个方面，采用“垃圾（废品）名称：值”的固定格式。例如：
c16。Trash。Glass：54
600
…………………………………………………………Page 602……………………………………………………………
c16。Trash。Paper：22
c16。Trash。Paper：11
c16。Trash。Glass：17
c16。Trash。Aluminum：89
c16。Trash。Paper：88
c16。Trash。Aluminum：76
c16。Trash。Cardboard：96
c16。Trash。Aluminum：25
c16。Trash。Aluminum：34
c16。Trash。Glass：11
c16。Trash。Glass：68
c16。Trash。Glass：43
c16。Trash。Aluminum：27
c16。Trash。Cardboard：44
c16。Trash。Aluminum：18
c16。Trash。Paper：91
c16。Trash。Glass：63
c16。Trash。Glass：50
c16。Trash。Glass：80
c16。Trash。Aluminum：81
c16。Trash。Cardboard：12
c16。Trash。Glass：12
c16。Trash。Glass：54
c16。Trash。Aluminum：36
c16。Trash。Aluminum：93
c16。Trash。Glass：93
c16。Trash。Paper：80
c16。Trash。Glass：36
c16。Trash。Glass：12
c16。Trash。Glass：60
c16。Trash。Paper：66
c16。Trash。Aluminum：36
c16。Trash。Cardboard：22
注意在给定类名的时候，类路径必须包含在内，否则就找不到类。
为解析它，每一行内容都会读入，并用字串方法 indexOf（）来建立“：”的一个索引。首先用字串方法
substring（）取出垃圾的类型名称，接着用一个静态方法 Double。valueOf（）取得相应的值，并转换成一个
double值。trim（）方法则用于删除字串两头的多余空格。
Trash 解析器置入单独的文件中，因为本章将不断地用到它。如下所示：
//： ParseTrash。java
// Open a file and parse its contents into
// Trash objects； placing each into a Vector
package c16。trash；
import java。util。*；
import java。io。*；
public class ParseTrash ｛
public static void
fillBin（String filename； Fillable bin） ｛
try ｛
BufferedReader data =
new BufferedReader（
601
…………………………………………………………Page 603……………………………………………………………
new FileReader（filename））；
String buf；
while（（buf = data。readLine（））！= null） ｛
String type = buf。substring（0；
buf。indexOf（'：'））。trim（）；
double weight = Double。valueOf（
buf。substring（buf。indexOf（'：'） ＋ 1）
。trim（））。doubleValue（）；
bin。addTrash（
Trash。factory（
new Trash。Info（type； weight）））；
｝
data。close（）；
｝ catch（IOException e） ｛
e。printStackTrace（）；
｝ catch（Exception e） ｛
e。printStackTrace（）；
｝
｝
// Special case to handle Vector：
public static void
fillBin（String filename； Vector bin） ｛
fillBin（filename； new FillableVector（bin））；
｝
｝ ///：~
在RecycleA。java 中，我们用一个Vector 容纳Trash 对象。然而，亦可考虑采用其他集合类型。为做到这一
点，fillBin（）的第一个版本将获取指向一个 Fillable 的句柄。后者是一个接口，用于支持一个名为
addTrash（）的方法：
//： Fillable。java
// Any object that can be filled with Trash
package c16。trash；
public interface Fillable ｛
void addTrash（Trash t）；
｝ ///：~
支持该接口的所有东西都能伴随fillBin 使用。当然，Vector 并未实现Fillable ，所以它不能工作。由于
Vector 将在大多数例子中应用，所以最好的做法是添加另一个过载的 fillBin（）方法，令其以一个 Vector 作
为参数。利用一个适配器（Adapter）类，这个Vector 可作为一个 Fillable 对象使用：
//： FillableVector。java
// Adapter that makes a Vector Fillable
package c16。trash；
import java。util。*；
public class FillableVector implements Fillable ｛
private Vector v；
public FillableVector（Vector vv） ｛ v = vv； ｝
public void addTrash（Trash t） ｛
v。addElement（t）；
｝
602
…………………………………………………………Page 604……………………………………………………………
｝ ///：~
可以看到，这个类唯一的任务就是负责将 Fillable 的addTrash（）同Vector 的addElement（）方法连接起来。
利用这个类，已过载的 fillBin（）方法可在ParseTrash。java 中伴随一个Vector 使用：
public static void
fillBin（String filename； Vector bin） ｛
fillBin（filename； new FillableVector（bin））；
｝
这种方案适用于任何频繁用到的集合类。除此以外，集合类还可提供它自己的适配器类，并实现 Fillable
（稍后即可看到，在DynaTrash。java 中）。
3。 原型机制的重复应用
现在，大家可以看到采用原型技术的、修订过的RecycleA。java 版本了：
//： RecycleAP。java
// Recycling with RTTI and Prototypes
package c16。recycleap；
import c16。trash。*；
import java。util。*；
public class RecycleAP ｛
public static void main（String＇＇ args） ｛
Vector bin = new Vector（）；
// Fill up the Trash bin：
ParseTrash。fillBin（〃Trash。dat〃； bin）；
Vector
glassBin = new Vector（）；
paperBin = new Vector（）；
alBin = new Vector（）；
Enumeration sorter = bin。elements（）；
// Sort the Trash：
while（sorter。hasMoreElements（）） ｛
Object t = sorter。nextElement（）；
// RTTI to show class membership：
if（t instanceof Aluminum）
alBin。addElement（t）；
if（t instanceof Paper）
paperBin。addElement（t）；
if（t instanceof Glass）
glassBin。addElement（t）；
｝
Trash。sumValue（alBin）；
Trash。sumValue（paperBin）；
Trash。sumValue（glassBin）；
Trash。sumValue（bin）；
｝
｝ ///：~
所有Trash 对象——以及ParseTrash 及支撑类——现在都成为名为c16。trash 的一个包的一部分，所以它们
可以简单地导入。
无论打开包含了 Trash 描述信息的数据文件，还是对那个文件进行解析，所有涉及到的操作均已封装到
603
…………………………………………………………Page 605……………………………………………………………
static （静态）方法ParseTrash。fillBin（）里。所以它现在已经不是我们设计过程中要注意的一个重点。在
本章剩余的部分，大家经常都会看到无论添加的是什么类型的新类，ParseTrash。fillBin（）都会持续工作，
不会发生改变，这无疑是一种优良的设计方案。
提到对象的创建，这一方案确实已将新类型加入系统所需的变动严格地“本地化”了。但在使用 RTTI 的过程
中，却存在着一个严重的问题，这里已明确地显露出来。程序表面上工作得很好，但却永远侦测到不能“硬
纸板”（Cardboard）这种新的废品类型——即使列表里确实有一个硬纸板类型！之所以会出现这种情况，完
全是由于使用了RTTI 的缘故。RTTI 只会查找那些我们告诉它查找的东西。RTTI 在这里错误的用法是“系统
中的每种类型”都进行了测试，而不是仅测试一种类型或者一个类型子集。正如大家以后会看到的那样，在
测试每一种类型时可换用其他方式来运用多形性特征。但假如以这种形式过多地使用 RTTI，而且又在自己的
系统里添加了一种新类型，很容易就会忘记在程序里作出适当的改动，从而埋下以后难以发现的 Bug。因
此，在这种情况下避免使用RTTI 是很有必要的，这并不仅仅是为了表面好看——也是为了产生更易维护的代
码。
16。5 抽象的应用
走到这一步，接下来该考虑一下设计方案剩下的部分了——在哪里使用类？既然归类到垃圾箱的办法非常不
雅且过于暴露，为什么不隔离那个过程，把它隐藏到一个类里呢？这就是著名的“如果必须做不雅的事情，
至少应将其本地化到一个类里”规则。看起来就象下面这样：
现在，只要一种新类型的Trash �
