| |
作者：yvon sauvageau
摘要
将 applet 参数化通常是一项烦琐的工作，包括在 applet 的 init() 方法中添加很多重复的代码行。上个月，java 技巧的撰稿人 yvon sauvageau 向您讲述了如何将这些代码缩减为一行，这要归功于类反射机制。但是，他没有说明如何实现数组初始化。本技巧将说明使数组自动初始化的细节。
上个月，我在 java tip 57，"applet parameterization via class reflection" 中提供了一个出色的方法来使 applet 参数化。参数化是指借助嵌入在 html 文件中的 param 标记来传递参数。这个方法用起来很方便，因为它完成了全部的参数提取工作，使您在相当长的时间内不必输入 getparameter。但在上一篇技巧中我没提及如何实现数组初始化。本月的这篇技巧将为您讲述这个问题。
本文假定您比较熟悉类反射机制，尽管您可能在查看代码时就能对它有所了解。类反射机制的功能部件位于 java.lang.reflect 软件包内。这种机制使您能够检查类的结构，还可提供域、方法、访问修饰符等的运行时信息。
将列表数据提供给 applet
看过关于 applet 参数化的上一篇技巧的读者可能已经注意到：我们的方法没有对一类重要的对象进行初始化。在本文中，我们将研究如果利用类反射机制对一维数组和二位数组进行初始化。我知道只有实现对更高维数组的处理才能使狂热的科学家满意，但我将把那项工作作为练习留给您。
在我的上一篇技巧中，只能处理基本类型的数组和字符串数组。考虑到任何对象最终都能由基本数据类型和字符串构建而来，所以这将不会构成多大的限制。当然，很容易将我们的技术加以扩展，之后就能直接对其他类型的数据进行初始化。
数组是用来存储列表数据的理想数据结构。我们的技术使得向 applet 传递列表参数变得很简单。 通常利用动态生成 html 文档的程序（如 servlet 或 cgi 脚本）将列表数据传递给 applet。作为示例，我们设想一个比赛记分板 applet。html 生成器将会将当前的记分板数据库输出到 param 标记中，接着相应的数组将被完全初始化 -- 这要归功于我们的参数提取方法。
列表数据项的语法
我们要实现的就是一个从 param 标记中提取一维或是二维数组的方法。一维数组的语法是：
param name="myarray" value="element1 element2 ... elementn"
各元素之间的定界符是空格。
二位数组的语法是：
param name="mymatrix" value="element11 element12 element13 |
element21 element22 element23 |
element31 element32 element33"
各行之间的定界符是 | 符号。这里，mymatrix 是一个 (3 x 3) 数组。
注意：java 支持不规则数组。 不规则数组就是各行的长度不同的数组。例如，html 作者可能会按以下方式输入帕斯卡三角形：
param name="pascaltriangle" value=" 1 |
1 1 |
1 2 1 |
1 3 3 1 |
1 4 6 4 1 |
1 5 10 10 5 1 |
1 6 15 20 15 6 1"
初始化完成之后，pascaltriangle 域的内容将是：
pascaltriangle[0] = {1}
pascaltriangle[1] = {1, 1}
pascaltriangle[2] = {1, 2, 1}
pascaltriangle[3] = {1, 3, 3, 1}
pascaltriangle[4] = {1, 4, 6, 4, 1}
pascaltriangle[5] = {1, 5, 10, 10, 5, 1}
pascaltriangle[5] = {1, 6, 15, 20, 15, 6, 1}
通常，程序员应该只声明 pascaltriangle，而不进行内存分配。我们的提取方法负责分配内存。但让我们假定已为第四行分配了内存，如下所示：
pascaltriangle[3] = new int[2];
我们的方法将只提取前两个元素。这样，第四行的初始化结果将是：
pascaltriangle[3] = {1, 3}
数组知识回顾
正如您在以上代码清单中看到的那样，我们的方法实现有点“深奥”。因此，在研究源代码之前回顾有关数组的几点知识是个不错的主意。
我们都对 java 的类型层次结构比较熟悉：java 有一组预定义的基本数据类型（int、float...），还有 object 的子类的一个继承树，object 类是所有类的最终超类。但 java 中还存在一个不很出名的平行层次结构，我称其为数组层次结构。您无论何时在类型层次结构中定义了一个新类型 foo，您实际上也同时定义了一个自动结合到数组层次结构中的新类型 foo[]。数组层次结构中的每个类（基本数据类型的数组除外）都是 object[] 的子类。容易引起混淆的是：object[] 和基本数据类型的数组都是 object 的子类。图 1 表明了这一点。
图 1：两个平行的层次结构
令人感到奇怪的是，java 根本就没有多维数组，只有一维数组。多维数组实际上是“一维数组的数组的数组的数组...”。因此，我们可以创建不规则数组。事实上，我们甚至可以不对某些行进行初始化，而将它们保留为空值。
数组提取方法的实现
现在我们可以查看源代码了。正如您所见，其中加了大量注释。通常，包含如此多的注释不是个好习惯，但在这里，我们要将已经抽象的 java 数组包装在由类反射机制提供的元数据抽象层中。结果，多数程序语句都不能表明其自身的含义，所以在这种情况下对几乎每个代码行作注释是无可非议的。
无论何时对一维或是二维数组进行初始化，最终我们都需要用 html 作者输入的行对一维数组进行初始化。我们设计了一个方法来完成这一操作：
/**
* 用符号处理器 (tokenizer) 的内容填充一维数组。
* 符号被转换为数组的内容类型。
*
* @param array 要填充的数组。
* @param elementtokens 包含要填入数组的符号的符号处理器。
*/
private static void fillonedimensionalarray(object array,
stringtokenizer elementtokens)
throws illegalaccessexception {
if (array != null && elementtokens != null && array.getclass().isarray()) { // 双重检验。
// 数组应该容纳哪种类型的元素？
class componenttype = array.getclass().getcomponenttype();
int numelements = elementtokens.counttokens();
// 为数组元素赋值。
//
// 请注意，我们确保索引不会超出范围。可能未给数组分配组足够的空间，
// 以致无法容纳分析后的全部元素。
for (int j = 0; j < array.getlength(array) && j < numelements; j++) {
// 将符号转换为数组所容纳的类型。
// 然后将其添加到数组中。
if (componenttype.equals(boolean.class))
array.setboolean(array, j, boolean.valueof(elementtokens.nexttoken().trim()).booleanvalue());
else if (componenttype.equals(byte.class))
array.setbyte(array, j, byte.valueof(elementtokens.nexttoken().trim()).bytevalue());
else if (componenttype.equals(char.class))
array.setchar(array, j, elementtokens.nexttoken().charat(0));
else if (componenttype.equals(double.class))
array.setdouble(array, j, double.valueof(elementtokens.nexttoken().trim()).doublevalue());
else if (componenttype.equals(float.class))
array.setfloat(array, j, float.valueof(elementtokens.nexttoken().trim()).floatvalue());
else if (componenttype.equals(int.class))
array.setint(array, j, integer.valueof(elementtokens.nexttoken().trim()).intvalue());
else if (componenttype.equals(long.class))
array.setlong(array, j, long.valueof(elementtokens.nexttoken().trim()).longvalue());
else if (componenttype.equals(short.class))
array.setshort(array, j, short.valueof(elementtokens.nexttoken().trim()).shortvalue());
else if (componenttype.equals(string.class))
array.set(array, j, elementtokens.nexttoken());
}
}
}
我们使用 class.getcomponenttype() 方法获取给定数组对象所容纳的元素类型。一旦我们获得这些信息，我们就知道应将行元素转换为何种类型。这是在一个循环语句中完成的。
您可能已猜到了，array.setbyte(object obj, int i, byte datum) 用字节变量 datum 为 obj 数组的第 i 个元素赋值。这相当于 ((byte[])obj)[i] = datum。
下面开始分析实现的核心部分。我对 util.initializeapplet(applet, string) 方法（在“java 技巧 57”中实现）进行了扩展，在其中添加了一个条件语句，这个条件语句高速缓存数组域并对它们进行初始化。
import java.applet.*;
import java.lang.reflect.*;
import java.util.*;
public abstract class util {
/**
* 对 applet 的名称以给定筛选前缀开头的非 final 公共域进行初始化。
* 初始值将从 html param 标记中读取。
* *
* @param applet 要初始化的 applet。
* @param filterprefix 只对那些以此前缀开头的域进行初始化。
*
* 如果前缀为空值，将对所有非 final 公共域进行初始化。
*/
public static void initializeapplet(applet applet, string filterprefix) {
class metaclass = applet.getclass();
field[] fields = metaclass.getfields();
string param = null;
for (int i = 0; i < fields.length; i++) {
try {
param = applet.getparameter(fields[i].getname());
if (param == null ||
modifier.isfinal(fields[i].getmodifiers()) ||
((filterprefix != null) &&
!fields[i].getname().startswith(filterprefix))
)
continue;
class fieldtype = fields[i].gettype();
if (fieldtype.equals(boolean.class)) {
fields[i].setboolean(applet, boolean.valueof(param).booleanvalue());
}
else if (fieldtype.equals(byte.class)) {
fields[i].setbyte(applet, byte.valueof(param).bytevalue());
}
/*********************************************
* 具体细节已被删除。请参阅上一篇文章。
* 要获得完整的代码，请下载源文件。
*********************************************/
// 对数组进行初始化。
else if (fieldtype.isarray()) {
// 此处我们知道正在处理的域是一个数组。
// 但数组要容纳何种类型的元素呢？
class componenttype = fieldtype.getcomponenttype();
// 对一维数组进行初始化。
if (componenttype.isprimitive() ||
componenttype.equals(string.class)) {
// 用 stringtokenizer 分析由 html 作者提供的数组元素。
stringtokenizer elementtokens = new stringtokenizer(param);
int numelements = elementtokens.counttokens();
// 请注意，fields[i] 只是表示数组对象的元数据域。
// 我们需要一个数组引用，以便为它的元素赋值。
//
// 这样：
object array = fields[i].get(applet);
// 如因某种原因已构造了数组，
// 则使它保持原样。
// 否则：以适当的类型构造数组，
// 并为其分配足够的内存空间，
// 以容纳由 html 作者提供全部元素。
if (array == null) {
// 构造类型为 componenttype 的数组，
// 并为 numelements 分配空间。
fields[i].set(applet, array.newinstance(componenttype, numelements));
// 获取刚构造的数组的引用。
array = fields[i].get(applet);
}
// 用包含在 elementtokens 中的元素填充数组。
fillonedimensionalarray(array, elementtokens);
}
// 对二维数组进行初始化。
else if (componenttype.isarray() &&
(componenttype.getcomponenttype().isprimitive() ||
componenttype.getcomponenttype().equals(string.class))) {
// 子数组（即各行）由 "|" 符号分隔。
// 使用这种定界符将二维表分解成一系列表示一维数组的
// 符号。我们称之为子数组。
stringtokenizer subarraytokens = new stringtokenizer(param, "|");
int numsubarrays = subarraytokens.counttokens();
// 请注意，"fields[i]" 只是表示数组对象的元数据域。
// 我们需要此数组的一个引用，以便为它的元素赋值。
//
// 这样：
object array = fields[i].get(applet);
// 如因某种原因已构造了数组，
// 则使它保持原样。
//
// 否则：以适当的类型构造数组，
// 并为其分配足够的内存空间，
// 以容纳 html 作者提供的全部行。
//
// 请注意，此处的变量 "array" 必定是数组的数组。
// 因此“适当的类型”必定是数组类型。
if (array == null) {
// 构造类型为 componenttype 的数组，
// 并为 numsubarrays 行分配内存空间。
fields[i].set(applet, array.newinstance(componenttype, numsubarrays));
// 获取刚构造的数组的数组的引用。
array = fields[i].get(applet);
}
// 依次对每个子数组进行初始化。
// 请注意，我们确保索引不超出范围。
// 可能是为数组分配的空间不足，
// 以致无法容纳 html 作者提供的所有行。
for (int j = 0; j < array.getlength(array) && j < numsubarrays; j++) {
// 用 stringtokenizer 分析由 html 作者提供的行元素。
stringtokenizer elementtokens = new stringtokenizer(subarraytokens.nexttoken());
int numelements = elementtokens.counttokens();
// 引入此新变量的唯一目的就是使代码更易于阅读。
// 但稍后我们就会看到这引起了敏感的争论。 object subarray = ((object[])array)[j];
// 如因某种原因已构造了子数组，
// 则使它保持原样。
//
// 否则：以适当的类型构造子数组，并为其分配充足的内存空间，
// 以便容纳由 html 作者提供的全部元素。
if (subarray == null) {
// "componenttype" 是 "array" 的类型，因此子数组的类型 "componenttype.getcomponenttype()" 的数组即为 "subarray" 的类型。
subarray = array.newinstance(componenttype.getcomponenttype(), numelements);
}
// 下面的语句是必要的。在前面的条件语句中，
// 可能已为 "subarray" 分配了一个不同于
// "((object[]array)[j]" 的对象引用。
// 这样就为这两个变量重新分配的别名。
// 这样就确保应用于子数组的全部变化
// 将在子数组的数组（即 "array"）中得到反映。
((object[])array)[j] = subarray;
// 用 elementtokens 中包含的元素填充子数组。
fillonedimensionalarray(subarray, elementtokens);
}
}
}
}
catch (exception e) {
system.err.println(e + " while initializing " + fields[i]);
}
}
}
}
当 type 为 {void.class, boolean.class, byte.class, short.class, int.class, long.class, float.class, double.class} 之一时，type.isprimitive() 方法即返回 "true"。
分配数组的类反射方法如下所示：
bazfield.set(fooobject, array.newinstance(componenttype, numelements));
这将创建数组并为其分配存储空间，然后用该数组为由变量 bazfield 表示且属于变量 fooobject 的域赋值。换句话说，fooobject 类的 fooclass 有一个由 bazfield 表示的属性，同时我们用这个数组为 fooclass 的 fooobject 实例中的相应域赋值。
以下语句的语法和语义都可能令您吃惊。
object subarray = ((object[])array)[j];
该语句的目的是从名为 array 的二维数组中提取第 j 行。我们将该行存储在变量 subarray 中。这个变量的类型 object，因为我们预先不知道要处理的一维数组为何种类型；回忆一下前面关于数组的讨论，任何类型的一维数组的最近公共超类即 object 类。若不是另有原因，该变量数组的类型也是 object。我们预先不知道要处理的是基本类型的一维数组，还是其他类型的数组，同样，最近的公共超类仍是 object。当我们看到这条语句时，我们已经知道了这样一个事实：变量 array 表示一个二维数组；回忆一下我们关于数组的讨论，二维数组实际上是一维数组的一维数组。因此，它们实际上都是 object[] 的子类。这就是我们能将变量 array 转换为 object[] 的原因所在。接下来的工作就很简单了，提取第 j 行作为 object 实例，并将其赋给变量 subarray。
小结
本技巧说明了如何利用类反射机制来减轻程序员开发可配置 applet 的负担。本月的这篇技巧用数组提取例程对我们的技术作了补充。通过使用一个完成所有参数提取工作的方法，您就免除了不得不一再输入 getparameter 的乏味工作。
作者简介
yvon.sauvageau yvon 获得了 mcgill 大学（位于加拿大蒙特利尔市）的数学及计算机科学学位。他有七年的编程经验，范围涉及商业服务器应用程序到 gui 编程。两年前他迷上了 java（没办法！）。他去年一月份通过了 sun 认证 java 程序员考试，最近又通过了 sun 认证 java 开发员考试。他目前是巴黎 mtli-nsk 技术公司的一名咨询人员。他目前承担的项目是一个人力资源管理系统，该系统完全用 java 编写，并且基于 objectstore oodbms。在欧洲的生活很有乐趣，但作为加拿大人他很想念曲棍球！
参考资源
下面是本技巧的源代码（zip 格式）：
javatip59.zip
下面是本技巧的源代码（jar 格式）：
javatip59.jar
请参阅我的上一篇技巧，"java tip 57: applet parameterization via class reflection"
http://www.javaworld.com/javatips/jw-javatip57.html
有关类反射的信息，请参阅 chuck mcmanis 在 javaworld 发表的文章，"take an in-depth look at the java reflection api"
http://www.javaworld.com/javaworld/jw-09-1997/jw-09-indepth.html
|
|
