欧美不卡一区二区,欧美久久久久久,中文字幕第一区

ammay — Wed, 16 Dec 2009 14:48:00 GMT

解析 Java �c�d��对象的初始化�q�程

�׃��个单态模式引出的问题谈�v

文档选项

		打印本页
		��此��作为电子邮件发�?/strong>

�U�别�Q?初��

�?国徏 (guojian.zhang@gmail.com), 软�g工程�? 北京高伟达西南分�?br />

2006 �q?8 �?31 �?/p>

�cȝ��初始化和对象初始化是 JVM ��理的类型生命周期中非常重要的两个环节，Google 了一遍网�l�，有关�c�装载机制的文章倒是不少�Q�然而类初始化和对象初始化的文章�q�不多，特别是从字节码和 JVM 层次来分析的文章更是鲜有所见�?/p>
本文主要对类和对象初始化全过�E�进行分析，通过一个实际问题引入，��源代码转换�?JVM 字节码后�Q�对 JVM 执行�q�程的关键点�q�行全面解析�Q��ƈ在文中穿插入了相�?JVM 规范�?JVM 的部分内部理论知识，以理��Z��实际�l�合的方式介�l�对象初始化和类初始化之间的协作以及可能存在的冲�H�问题�?/p>

问题引入

�q�日我在调试一个枚丄��型的解析器程序，该解析器是将数据库内一万多条枚举代码装载到�~�存中，��Z��实现快速定位枚举代码和具体枚�D�c�d��的所有枚丑օ�素，该类在装载枚举代码的同时对其采取两种�{�略建立内存索引。由于该�c�L��一个公共服务类�Q�在�E�序各个层面都会使用到它�Q�因此我��它实现��Z��个单例类。这个类在我调整�c�d��例化语句位置之前�q�行正常�Q�但当我把该�c�d��例化语句调整到静态初始化语句之前�Ӟ��我的�E�序不再为我工作了�?/p>

下面是经�q�我��化后的示例代码：

�Q�L��单一�Q?/strong>

package com.ccb.framework.enums; import java.util.Collections; import java.util.HashMap; import java.util.Map; public class CachingEnumResolver { //单态实例　一切问题皆由此行引�? private static final CachingEnumResolver SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); /*MSGCODE->Category内存索引*/ private static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //��Z��说明问题,我在�q�里初始化一条数�? CODE_MAP_CACHE.put("0","北京�?); } //private, for single instance private CachingEnumResolver() { //初始化加载数�? 引�v问题�Q�该�Ҏ��也要负点责�Q initEnums(); } /** * 初始化所有的枚�D�c�d�� */ public static void initEnums() { // ~~~~~~~~~问题从这里开始暴�?~~~~~~~~~~~// if (null == CODE_MAP_CACHE) { System.out.println("CODE_MAP_CACHE为空,问题在这里开始暴�?"); CODE_MAP_CACHE = new HashMap(); } CODE_MAP_CACHE.put("1", "北京�?); CODE_MAP_CACHE.put("2", "云南�?); //..... other code... } public Map getCache() { return Collections.unmodifiableMap(CODE_MAP_CACHE); } /** * 获取单态实�? * * @return */ public static CachingEnumResolver getInstance() { return SINGLE_ENUM_RESOLVER; } public static void main(String[] args) { System.out.println(CachingEnumResolver.getInstance().getCache()); } }

惛_��大家看了上面的代码后会感觉有些茫�Ӟ��q�个�cȝ��h��没有问题啊，�q�的��属于典型的饿汉式单态模式啊�Q�怎么会有问题呢？

是的�Q�他看�v来的��没有问题，可是如果��他 run ��h��Ӟ��其结果是他不会�ؓ你正��?work。运行该�c�，它的执行�l�果是：

�Q�L��单二�Q?/strong>

CODE_MAP_CACHE为空,问题在这里开始暴�? {0=北京市}

我的�E�序怎么会这��P��Z��么在 initEnum() �Ҏ��?CODE_MAP_CACHE 为空�Q��ؓ什么我输出�?CODE_MAP_CACHE 内容只有一个元素，其它两个元素呢？�Q�？�Q�！�Q?/p>
看到�q�里�Q�如果是你在调试该程序，你此��M��定觉得很奇怪，��N��是我�?Jvm 有问题吗�Q�非也！如果不是�Q�那我的�E�序是怎么了？�q�绝对不是我惌��的结果。可事实上无论怎么修改 initEnum() �Ҏ��都无��于事，��L��我最初是一定不会怀疑到问题可能出在创徏 CachingEnumResolver 实例�q�一环节上。正是因为我太相信我创徏 CachingEnumResolver 实例的方法，加之�?Java �c�d��始化与对象实例化底层原理理解有所偏差�Q��我�ؓ此付��Z��三、四个小�?-�U�半个工作日的大好青春�?/p>
那么问题�I�竟出在哪里呢？��Z��么会出现�q�样的怪事呢？在解册��个问题之前，先让我们来了解一下JVM的类和对象初始化的底层机制�?/p>

回页�?/strong>

�cȝ��生命周期

上图展示的是�cȝ��命周期流向；在本文里�Q�我只打��谈谈类�?初始�?以及"对象实例�?两个阶段�?/p>

回页�?/strong>

�c�d��始化

�c?初始�?阶段�Q�它是一个类或接口被首次使用的前阶段中的最后一��工作，本阶�D�负责�ؓ�c�d��量赋予正��的初始倹{�?/p>
Java �~�译器把所有的�c�d��量初始化语句和类型的静态初始化器通通收集到 �Ҏ��内，该方法只能被 Jvm 调用�Q�专门承担初始化工作�?/p>
除接口以外，初始化一个类之前必须保证其直接超�c�d��被初始化�Q��ƈ且该初始化过�E�是�?Jvm 保证�U�程安全的。另外，�q��所有的�c�都会拥有一�?() �Ҏ��Q�在以下条�g中该�c�M��会拥�?() �Ҏ��Q?/p>

该类既没有声明�Q何类变量�Q�也没有静态初始化语句�Q?
该类声明了类变量�Q�但没有明确使用�c�d��量初始化语句或静态初始化语句初始化；
该类仅包含静�?final 变量的类变量初始化语句，�q�且�c�d��量初始化语句是编译时帔R��表达式�?

回页�?/strong>

对象初始�?/span>

在类被装载、连接和初始化，�q�个�c�d��随时都可能��用了。对象实例化和初始化是就是对象生命的起始阶段的活动，在这里我们主要讨论对象的初始化工作的相关特点�?/p>
Java �~�译器在�~�译每个�c�L��都会��c�至��生成一个实例初始化�Ҏ��--�?"()" �Ҏ��。此�Ҏ��与源代码中的每个构造方法相对应�Q�如果类没有明确地声明�Q何构造方法，�~�译器则��cȝ��成一个默认的无参构造方法，�q�个默认的构造器仅仅调用父类的无参构造器�Q�与此同时也会生成一个与默认构造方法对应的 "()" �Ҏ��.

通常来说�Q?lt;init>() �Ҏ��内包括的代码内容大概为：调用另一�?() �Ҏ��Q�对实例变量初始化；与其对应的构造方法内的代码�?/p>
如果构造方法是明确��C��调用同一个类中的另一个构造方法开始，那它对应�?() �Ҏ��体内包括的内容�ؓ�Q�一个对本类�?() �Ҏ��的调用；对应用构造方法内的所有字节码�?/p>
如果构造方法不是通过调用自��n�cȝ��其它构造方法开始，�q�且该对象不�?Object 对象�Q�那 () 法内则包括的内容为：一个对父类 () �Ҏ��的调用；对实例变量初始化�Ҏ��的字节码�Q�最后是对应构造子的方法体字节码�?/p>
如果�q�个�c�L�� Object�Q�那么它�?() �Ҏ��则不包括对父�c?() �Ҏ��的调用�?/p>

回页�?/strong>

�cȝ��初始化时�?/span>

本文到目前�ؓ止，我们已经大概有了解到了类生命周期中都�l�历了哪些阶�D�，但这个类的生命周期的开始阶�D?-�c�装载又是在什么时候被触发呢？�c�d��是何时被初始化的呢？让我们带着�q�三个疑问��l�去��L��{�案�?/p>
Java 虚拟��范�ؓ�cȝ��初始化时机做了严格定义："initialize on first active use"--" 在首�ơ主动��用时初始�?。这个规则直接媄响着�c�装载、连接和初始化类的机�?-因�ؓ在类型被初始化之前它必须已经被连接，然而在�q�接之前又必��M��证它已经被装载了�?/p>
在与初始化时机相关的�c�装载时机问题上�Q�Java 虚拟��范�ƈ没有对其做严格的定义�Q�这��׃��?JVM 在实��C��可以�Ҏ��自己的特�Ҏ��供采用不同的装蝲�{�略。我们可以思考一�?Jboss AOP 框架的实现原理，它就是在对你�?class 文�g装蝲环节做了手脚--插入�?AOP 的相��x��截字节码�Q�这使得它可以对�E�序员做到完全透明化，哪怕你�?new 操作�W�创建出的对象实例也一栯��?AOP 框架拦截--与之相对应的 Spring AOP�Q�你必须通过他的 BeanFactory 获得�?AOP 代理�q�的受管对象�Q�当�?Jboss AOP 的缺点也很明�?-他是�?JBOSS 服务器绑定很紧密的，你不能很��L��的移植到其它服务器上。嗯~……�Q�说到这里有些跑题了�Q�要知道 AOP 实现�{�略��_��以写一本厚厚的书了�Q�嘿嘿，��此打住�?/p>
说了�q�么多，�cȝ��初始化时机就是在"在首�ơ主动��用时"�Q�那么，哪些情�Ş下才�W�合首次��d��使用的要求呢�Q?/p>
首次��d��使用的情形：

创徏某个�cȝ��新实例时--new、反��、克隆或反序列化�Q?
调用某个�cȝ��静态方法时�Q?
使用某个�c�L��接口的静态字�D�|��对该字段赋值时�Q�final字段除外�Q�；
调用Java的某些反��方法时
初始化某个类的子�c�L��
在虚拟机启动时某个含有main()�Ҏ��的那个启动类�?

除了以上几种情�Ş以外�Q�所有其它��用JAVA�c�d��的方式都是被动��用的�Q�他们不会导致类的初始化�?/p>

回页�?/strong>

我的问题�I�竟出在哪里

好了�Q�了解了JVM的类初始化与对象初始化机制后�Q�我们就有了理论基础�Q�也��可以理性的��d��析问题了�?/p>
下面让我们来看看前面[清单一]的JAVA源代码反�l�译出的字节码：

�Q�L��单三�Q?/strong>

public class com.ccb.framework.enums.CachingEnumResolver extends java.lang.Object{ static {}; Code: 0: new #2; //class CachingEnumResolver 3: dup 4: invokespecial #14; //Method "":()V �? 7: putstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; 10: new #18; //class HashMap �? 13: dup 14: invokespecial #19; //Method java/util/HashMap."":()V 17: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 20: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 23: ldc #23; //String 0 25: ldc #25; //String 北京�? 27: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; �? 32: pop 33: return private com.ccb.framework.enums.CachingEnumResolver(); Code: 0: aload_0 1: invokespecial #34; //Method java/lang/Object."":()V 4: invokestatic #37; //Method initEnums:()V �? 7: return public static void initEnums(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; �? 3: ifnonnull 24 6: getstatic #44; //Field java/lang/System.out:Ljava/io/PrintStream; 9: ldc #46; //String CODE_MAP_CACHE为空,问题在这里开始暴�? 11: invokevirtual #52; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 14: new #18; //class HashMap 17: dup 18: invokespecial #19; //Method java/util/HashMap."":()V �? 21: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 24: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 27: ldc #54; //String 1 29: ldc #25; //String 北京�? 31: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; �? 36: pop 37: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 40: ldc #56; //String 2 42: ldc #58; //String 云南�? 44: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; �? 49: pop 50: return public java.util.Map getCache(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 3: invokestatic #66; //Method java/util/Collections.unmodifiableMap:(Ljava/util/Map;)Ljava/util/Map; 6: areturn public static com.ccb.framework.enums.CachingEnumResolver getInstance(); Code: 0: getstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; �? 3: areturn }

如果上面�Q�L��单一�Q�显�C�，清单内容是在 JDK1.4 环境下的字节码内容，可能�q�䆾清单对于很大部分兄弟来说��实没有多少吸引力，因�ؓ�q�些 JVM 指��o��实不像源代码那��h��亮易懂。但它的的确��是查找和定位问题最直接的办法，我们惌��的答案就在这�?JVM 指��o清单里�?/p>
现在�Q�让我们对该�c�M��c�d��始化到对象实例初始化全过�E�分析[清单一]中的代码执行轨迹�?/p>
如前面所�q�ͼ��c�d��始化是在�cȝ��正可用时的最后一��前阶工作，该阶�D�负责对所有类正确的初始化��|��此项工作是线�E�安全的�Q�JVM会保证多�U�程同步�?/p>
�W�１步：调用�c�d��始化�Ҏ�� CachingEnumResolver.()�Q�该�Ҏ��对外界是不可见的�Q�换句话说是 JVM 内部专用�Ҏ��Q?lt;clinit>() 内包括了 CachingEnumResolver 内所有的��h��指定初始值的�c�d��量的初始化语句。要注意的是�q��每个�c�都��h��该方法，具体的内容在前面已有叙述�?/p>
�W�２步：�q�入 () �Ҏ��内，让我们看字节码中�?"�? 行，该行与其上面两行�l�合��h��代表 new 一�?CachingEnumResolver 对象实例�Q�而该代码行本�w�是指调�?CachingEnumResolver �cȝ�� Q�）�Ҏ��。每一�?Java �c�都��h��一�?() �Ҏ��Q�该�Ҏ��?Java �~�译器在�~�译时生成的�Q�对外界不可见，() �Ҏ��内包括了所有具有指定初始化值的实例变量初始化语句和java�cȝ��构造方法内的所有语句。对象在实例化时�Q�均通过该方法进行初始化。然而到此步�Q�一个潜在的问题已经在此埋伏好，��q��着你来犯了�?/p>
�W�３步：让我们顺着执行��序向下看，"�? 行，该行所在方法就是该�cȝ��构造器�Q�该�Ҏ��先调用父�cȝ��构造器 () 对父对象�q�行初始化，然后调用 CachingEnumResolver.initEnum() �Ҏ��加蝲数据�?/p>
�W�４步："�? 行，该行获取 "CODE_MAP_CACHE" 字段��|��其运行时该字�D��gؓ null。注意，问题已经开始显��C��。（作�ؓ�E�序员的你一定是希望该字�D�已�l�被初始化过了，而事实上它还没有被初始化�Q�。通过判断�Q�由于该字段�?NULL�Q�因此程序将�l�箋执行�?"�? 行，��该字段实例化�ؓ HashMap()�?/p>
�W�５步：�?"�?�?�? 行，其功能就是�ؓ "CODE_MAP_CACHE" 字段填入两条数据�?/p>
�W�６步：退出对象初始化�Ҏ�� ()�Q�将生成的对象实例初始化�l�类字段 "SINGLE_ENUM_RESOLVER"。（注意�Q�此刻该对象实例内的�c�d��量还未初始化完全�Q�刚才由 () 调用 initEnum() �Ҏ��赋值的�c�d��?"CODE_MAP_CACHE" �?() �Ҏ��q�未初始化字�D�，它还��在后面的类初始化过�E�再�ơ被覆盖�Q��?/p>
�W�７步：�l�箋执行 �Q�）�Ҏ��内的后��代码�Q?�? 行，该行�?"CODE_MAP_CACHE" 字段实例化�ؓ HashMap 实例�Q�注意：在对象实例化时已�l�对该字�D�赋��D��了，现在又重新赋��gؓ另一个实例，此刻�Q?CODE_MAP_CACHE"变量所引用的实例的�c�d��量��D��覆盖�Q�到此我们的疑问已经有了�{�案�Q��?/p>
�W?步：�c�d��始化完毕�Q�同时该单态类的实例化工作也完成�?/p>
通过对上面的字节码执行过�E�分析，或许你已�l�清楚了解到��D��错误的深层原因了�Q�也或许你可能早已被上面的分析过�E�给弄得晕头转向了，不过也没折，虽然我也可以从源代码的角度来阐述问题�Q�但�q�样不够深度�Q�同时也会有仅�ؓ个�h观点、不��_��信之嫌�?/p>

回页�?/strong>

如何解决

要解决上面代码所存在的问题很��单，那就是将 "SINGLE_ENUM_RESOLVER" 变量的初始化赋��D��句�{�U�d�� getInstance() �Ҏ��中去卛_��。换句话说就是要避免在类�q�未初始化完成时从内部实例化该类或在初始化过�E�中引用�q�未初始化的字段�?/p>

回页�?/strong>

写在最�?/span>

静下��燥之心�Q�仔�l�思量自己是否真的掌握了本文主题所引出的知识，如果您觉得您已经完全或基本掌握了�Q�那么很好，在最后，我将前面的代码稍做下修改�Q�请思考下面两�l�程序是否同样会存在问题呢？

�E�序一

public class CachingEnumResolver { public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //��Z��说明问题,我在�q�里初始化一条数�? CODE_MAP_CACHE.put("0","北京�?); initEnums(); }

�E�序�?/strong>

public class CachingEnumResolver { private static final CachingEnumResolver SINGLE_ENUM_RESOLVER; public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //��Z��说明问题,我在�q�里初始化一条数�? CODE_MAP_CACHE.put("0","北京�?); SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); initEnums(); }

最后，一点关�?JAVA ��体的感�a��Q�时下正是各�U�开源框架盛行时期，Spring 更是大行光��Q�吸引着一大批 JEE 开发者的眼球�Q�我也是 fans 中的一员）。然而，让我们仔�l�观察一�?-�?Spring ��体��Z��Q�在那么多的 Spring fans 当中�Q�有多少人去研究�q?Spring 源代码？又有多少人对 Spring 设计思想有真正深入了解呢�Q�当�Ӟ��我是没有资格以这��L��口吻来说事的�Q�我只是惌��明一个观�?-学东西一定要"正本清源"�?/p>
献上此文�Q��}以共勉�?/p>

关于作�?/span>

北京高伟达西南分�?Java EE 软�g工程师，三年 Java EE ��目�l�验�Q�行业方向�ؓ银行 OCRM �pȝ��。对 JAVA 有着��厚的兴��，业余研究 AOP/ESB 方向�?/p>

ammay 2009-12-16 22:48 发表评论

泛型

ammay — Mon, 14 Dec 2009 14:55:00 GMT

�~�者注�Q�在从Java in a Nutshell,5th edith中摘录的两部部分中的�W�一部分�Q�David Flanagan描述了如何��用泛型。这部分�Q�David Flanagan��具体告诉你如何创徏自己的泛型和泛型�Ҏ��Q��ƈ且以Java核心API很多重要的泛型作为结束�ȝ��?br />
创徏泛型和泛型方�?/strong>
创徏一个简单的泛型是非常容易的。首先，在一对尖括号(< >)中声明类型变量，以逗号间隔变量名列表。在�cȝ��实例变量和方法中�Q�可以在��M��c�d��的地方��用那些类型变量。切讎ͼ��c�d��变量仅在�~�译时存在，所以不能��用instanceof和new�q�类�q�行时操作符来操作类型变量�?br />
让我们以一个简单的例子来开始这部分的学习，而后��精��q�个例子。这�D�代码定义了一个树形数据结构，使用�c�d��变量V代表存储在各个树�l�点中的倹{�?br />

import java.util.*;
/**
* A tree is a data structure that holds values of type V.
* Each tree has a single value of type V and can have any number of
* branches, each of which is itself a Tree.
*/
public class Tree {
// The value of the tree is of type V.
V value;

// A Tree can have branches, each of which is also a Tree

List> branches = new ArrayList>();

// Here's the constructor. Note the use of the type variable V.
public Tree(V value) { this.value = value; }

// These are instance methods for manipulating the node value and branches.
// Note the use of the type variable V in the arguments or return types.
V getValue() { return value; }
void setValue(V value) { this.value = value; }
int getNumBranches() { return branches.size(); }
Tree getBranch(int n) { return branches.get(n); }
void addBranch(Tree branch) { branches.add(branch); }
}

正如你所看到的，命名一个类型变量习惯于一个大写字母。��用一个字母可以同现实中那些具有描�q�性的�Q�长的实际变量名有所区别。��用大写字母要同变量命名规则一��_��q�且要区别于局部变量，�Ҏ��参数�Q�成员变量，而这些变量常�怋�用一个小写字母。集合类中，比如java.util中常�怋�用类型变量E代表“Element type”。T和S常常用来表示范型变量名（好像使用i和j作�ؓ循环变量一��P��?br />
注意刎ͼ�当一个变量被声明为泛型时�Q�只能被实例变量和方法调用（�q�有内嵌�c�d��Q�而不能被静态变量和�Ҏ��调用。原因很��单，参数化的泛型是一些实例。静态成员是被类的实例和参数化的�c�L��׃�n的，所以静态成员不应该有类型参数和他们兌��。方法，包括静态方法，可以声明和��用他们自��q��c�d��参数�Q�但是，调用�q�样一个方法，可以被不同地参数化。这些内容将在本章后面谈到�?br />
�c�d��变量�l�定
上面例子中的Tree中的�c�d��变量V是不受约束的�Q�Tree可以被参数化��Z�Q何类型。以前我们常�怼�讄��一些约束条件在需要��用的�c�d��上：也许我们需要强制一个类型参数实��C��个或多个接口�Q�或是一个特定类的子�c�R��这可以通过指明�c�d��l�定来完成。我们已�l�看��C��l�配�W�的上界�Q�而且使用��单的语法可以指定一般类型变量的上界。后面的代码�Q�还是��用Tree�q�个例子�Q��ƈ且通过实现Serializable和Comparable来重写。�ؓ了做到这点，例子中��用类型变量绑定来��保值类型的Serializable和Comparable�?br />

import java.io.Serializable;
import java.util.*;

public class Tree>
implements Serializable, Comparable>

{
V value;
List> branches = new ArrayList>();

public Tree(V value) { this.value = value; }

// Instance methods
V getValue() { return value; }
void setValue(V value) { this.value = value; }
int getNumBranches() { return branches.size(); }
Tree getBranch(int n) { return branches.get(n); }
void addBranch(Tree branch) { branches.add(branch); }

// This method is a nonrecursive implementation of Comparable>

// It only compares the value of this node and ignores branches.
public int compareTo(Tree that) {
if (this.value == null && that.value == null) return 0;
if (this.value == null) return -1;
if (that.value == null) return 1;
return this.value.compareTo(that.value);
}

// javac -Xlint warns us if we omit this field in a Serializable class
private static final long serialVersionUID = 833546143621133467L;
}

一个类型变量的�l�定是通过extends后的名字和一个类型列表（�q�可以是参数化的�Q�就像Comparable一��P��表达的。注意当有不止一个绑定时�Q�就像上面例子中的，�l�定的类型要�?amp;作�ؓ分隔�W�，而不是��用逗号。都后用来分隔类型变量，如果用来分隔�c�d��变量�l�定�Q�就会模��׃��可。一个类型变量可以有��M��数量的绑定，包括��M��数量的借口和至多一个类�?br />
范型中的通配�W?/strong>
上一章的例子中我们看��C��通配�W�和控制参数化类型的通配�W�绑定。这些在范型中同样非常有用。当前设计的Tree要求每个节点有相同类型的��|��V。也许这样太严格了，也许我们应该让Tree的branches能够存放V的子�c�而不全是V。这个版本的Tree�Q�删除了Comparable和Serializable接口的实玎ͼ��q�样做会更灵�z�R�?br />

public class Tree {
// These fields hold the value and the branches
V value;
List> branches = new ArrayList>();

// Here's a constructor
public Tree(V value) { this.value = value; }

// These are instance methods for manipulating value and branches
V getValue() { return value; }
void setValue(V value) { this.value = value; }
int getNumBranches() { return branches.size(); }
Tree getBranch(int n) { return branches.get(n); }
void addBranch(Tree branch) { branches.add(branch); }
}

通配�W�绑定允许我们在枝节点上增加一个Tree�Q�比如，一个树枝Tree�Q?br />
Tree t = new Tree(0); // Note autoboxing
t.addBranch(new Tree(1)); // int 1 autoboxed to Integer

通过getBranch()查询树枝�Q�而树枝的�q�回�c�d��不知道，所以必��M��用统配符来表达。接下来的两个是合法的，但第三个不是�Q?br />
Tree b = t.getBranch(0);
Tree b2 = t.getBranch(0);
Tree b3 = t.getBranch(0); // compilation error

当我们这��h��查询一个树枝时�Q�不能精��确定它的返回类型，但是存在�c�d��的上限，所以，我们可以�q�样做：

Tree b = t.getBranch(0);
Number value = b.getValue();

那我们不能做什么呢�Q�设定树枝的��|��或者在原有的树枝上��d��新的树枝。早前章节解释的�Q�上界的存在不会改变�q�回值的�c�d��不可知，�~�译器没有��够的信息让我们安全的�l�setValue()或者一个树枝（包括值类型）的addBranch()传递一个倹{��下面的两行代码都是非法的：

b.setValue(3.0); // Illegal, value type is unknown
b.addBranch(new Tree(Math.PI));

�q�个例子在设计时扑ֈ�了一个��^衡点�Q��用绑定通配�W��得数据结构更加灵�z�，但是减少了安全��用其中方法的可能。这个设计是好是坏就要根据上下文联系了。通常�Q�好的范型设计是非常困难的。幸�q�的是，大多我们要��用的已经在java.util包中设计好了�Q�而不用我们自己再去设计�?br />
范型�Ҏ��
　　正如前面说的�Q�范型只能被实例成员调用�Q�而不是静态成员。同实例�Ҏ��一��P��静态方法也可以使用通配�W�。尽��静态方法不能��用包含他们的�c�M��的类型变量，但是他们可以声明自己的类型变量。当一个方法声明了自己的类型变量，��叫做范型方法�?br />
�q�里有一个要��d��到Tree中的静态方法。他不是一个范型方法，但是使用了绑定的通配�W�，��好像先前我们看到的sumList()一��P��

/** Recursively compute the sum of the values of all nodes on the tree */
public static double sum(Tree t) {
double total = t.value.doubleValue();
for(Tree b : t.branches) total += sum(b);
return total;
}

　　通过通配�W�的上界�l�定�Q�声明自��q��c�d��变量来重写这个方法：

public static double sum(Tree t) {
N value = t.value;
double total = value.doubleValue();
for(Tree b : t.branches) total += sum(b);
return total;
}

　　范型的sum()不比通配�W�版本的��单，而且声明变量�q�没有让我们获得什么。这�U�情况下�Q�通配�W�方案要比范型方法更有效�Q�当一个类型变量用来表达两个参��C��间或者参数和�q�回��g��间的关系�Ӟ��范型�Ҏ��才是需要的。请看下面的例子�Q?br />
// This method returns the largest of two trees, where tree size
// is computed by the sum() method. The type variable ensures that
// both trees have the same value type and that both can be passed to sum().
public static Tree max(Tree t, Tree u) {
double ts = sum(t);
double us = sum(u);
if (ts > us) return t;
else return u;
}
　　

�q�个�Ҏ��使用�c�d��变量N来约束参数和�q�回值有相同�c�d��Q��ƈ且参数是Number或者他的子�c�R�?br />
　　使得参数��h��相同�c�d��也许是有争议的，应该让我们能调用max()不论是Tree或者Tree。一�U�方法是使用两个不相�q�的�c�d��变量来表�C�Z��个不相干的值类型。注意，我们不能在方法的�q�回时��用变量而必��M��用通配�W�：

public static
Tree max(Tree t, Tree u) {...}

　　既然两个�c�d��变量N和M没有��M��联系�Q�而且每个仅在�{�֐�的时候��用，他们没有提供比通配�W�更多的好处�Q�这�U�方法最好这样写�Q?br />
public static Tree max(Tree t,
Tree u) {...}

所有在�q�里的范型方法都是静态的�Q�这�q�不是必��ȝ��Q�实例方法也可以声明自己的类型变量�?br />
调用范型�Ҏ��
当你使用范型�Ӟ��必须指定实际�c�d��参数来代替相应的�c�d��变量。但�q�些对范型方法有些不同：�~�译器��L��能计��出��Z��你所传递的参数的相应范型方法参数。考虑一下上面定义的max()�Q�作��Z��子：

public static Tree max(Tree t, Tree u) {...}

当你调用�q�个�Ҏ��Ӟ��不需要指明N�Q�因为N是隐含地由t和u指明。在后面的代码中�Q�编译器军_��N为Integer�Q?br />

Tree x = new Tree(1);
Tree y = new Tree(2);
Tree z = Tree.max(x, y);

�~�译器判断范型方法的参数�c�d��U�Cؓ�c�d��推断。类型推断是相对于知觉推断的。而实际编译器的实现方法是一�U�非常复杂的�q�程�Q�超�q�了�q�本书的讨论范围。更多的�l�节在The Java Language Specification, Third Edition的第十五章�?br /> 让我们看一个更加复杂的�c�d��推断�Q�考虑一下这个方法：

public class Util {
/** Set all elements of a to the value v; return a. */
public static T[] fill(T[] a, T v) {
for(int i = 0; i < a.length; i++) a[i] = v;
return a;
}
}

�q�里有两个该�Ҏ��的调用：

Boolean[] booleans = Util.fill(new Boolean[100], Boolean.TRUE);
Object o = Util.fill(new Number[5], new Integer(42));

在第一个例子中�Q�编译器可以��L��的推断出T是Boolean�c�d��Q�第二个例子中，�~�译器判断T是Number�?br /> 在非常罕见的情况下，你可能会昄��的指明范型方法的参数�c�d��。有时候这是必要的�Q�比如，当范型方法不需要参数时。考虑一下java.util.Collections.emptySet()�Q�返回一个空集合�Q�但是不同于Collections.singleton()�Q�可以在参考部分察看）�Q�他不带��M��参数�Q�但需要指明返回类型。通过在方法名前的<>中，可以昄��的指明参数类型：

Set empty = Collections.emptySet();

　　�c�d��参数不能同没有限制的�Ҏ��名结合��用：他们必须跟随在一�?后或者在关键字new后，或者在关键字this前，或者构造函数的super前�?br /> 可以证明�Q�如果如果你��Collections.emptySet()的返回��D��l�一个变量，��像我们上边通过�c�d��推断机制推断��Z��变量�c�d��的参数类型。尽��显�C�的�c�d��说明可以更加清楚�Q�但�q�不是必要的�Q�可以像下面一样重写：

Set empty = Collections.emptySet();

　　在方法调用表辑ּ�中，昄��的说明emptySet()的返回值类型是必要的。比如，假设你要调用一个名为printWords()的方法，该方法仅需一个Set的参敎ͼ�如果你想传递一个空的集合给该方法，��p��像下面一样写�Q?br />
printWords(Collections.emptySet());

�q�种情况下，昄��的类型说明是必要的�?br />
范型�Ҏ��和数�l?/strong>
早先我们看到�Q�编译器不允许创��Z��个类型参数化的数�l�。但是对于范型的使用会是不同的。考虑一下前面定义的Util.fill()�Q�它得以�W�一个参数和�q�回值类型都是T[]。而方法体内不必创��Z�Q何参��CؓT的数�l�，所以这个方法是合法的�?br />
如果你创��Z��个方法��用varargs�Q�参见第二章�?.6.4�Q�和�c�d��变量�Q�记住调用varargs隐含创徏一个数�l�，��L��下面的例子：

/** Return the largest of the specified values or null if there are none */
public static > T max(T... values) { ... }

你可以��用一个Integer�c�d��来调用这个方法，因�ؓ�~�译器会在调用的时候插入必要的数组创徏代码。但是你不能��参数�{换�ؓComparable来调用这个方法，因�ؓ创徏一个Comparable[]是不合法的�?br />
参数化异�?/strong>
异常是在�q�行时抛出和捕获的。没有办法让�~�译器完成类型检查，来保证在catch块中抛出的未知的�c�d��匚w��异常。由于这个原因，catch块很可能不包含类型变量和通配�W�。既然不可能保证在运行时捕获一个编译器时类型参数完整性异常，所以不允许创徏��M��Throwable�c�d��的子�c�R��参数化异常是不允许的�?br /> 但是你可以��用类型变量在throw块里的方法签名中。看看下面的例子�Q?br />

public interface Command {
public void doit(String arg) throws X;
}

�q�个接口描述了一�?#8220;command”�Q�一块代码只有一个String�c�d��的参敎ͼ�没有�q�回倹{��代码可能抛��Z��个类型�ؓX的异常。这里有一个例子��用这个接口：

Command save = new Command() {
public void doit(String filename) throws IOException {
PrintWriter out = new PrintWriter(new FileWriter(filename));
out.println("hello world");
out.close();
}
};

try { save.doit("/tmp/foo"); }
catch(IOException e) { System.out.println(e); }

范型个案研究�Q�比较和枚�D
Java1.5引入的范型新�Ҏ��，�?.5的API中有使用�Q�特别多的是在java.util包中�Q�但是在java.lang�Q�java.lang.reflect和java.util.concurrent中也有。这些API都是�l�过仔细的斟酌创建的�Q�通过学习�q�些API我们可以学到很多好的设计�Ҏ��?br />
java.util中的范�Ş是比较简单的�Q�因为大多都是集合类�Q�类型变量也是代表集合中的元素。java.lang中的几个重要范型是比较难以理解的�Q�他们不是集合，而且�W�一眼很不容易理解�ؓ什么设计成范型。学习这些范型可以让我们更深层次的理解范形的工作机制�Q��ƈ且介�l�一些我们没有提到的概念。特别的�Q�我们要��查Comparable接口和Enum�c�（枚�D�c�d��的超�c�，后面一张讲解）�q�且学习一些重要但是很��用的范型�Ҏ��，比如通配�W�下界�?br />
在java1.5中，Comparable接口被修改�ؓ范型的。大多数的类都实��C��q�个接口�Q�考虑一下Integer�Q?br />

public final class Integer extends Number implements Comparable

原先的Comparable接口在类型安全方面是有问题的。两个��承了Comparable接口的对象可能不能相互比较。JDK5.0前，非范形的Comparable接口是非常有用但是不安全的，而现在的接口�Q�捕获了我们需要的信息�Q�他告诉我们一个对象是可比较的�Q��ƈ且可以同什么比较�?br />
现在�Q�考虑一下comparable�cȝ��子类。Integer是final的，所以不能有子类�Q�那么让我们看看java.math.BigInteger�Q?br />

public class BigInteger extends Number implements Comparable

如果我们实现一个BiggerInteger�c�L��BigInteger的子�c�，他从父类那里�l�承了Comparable接口�Q�但是注意��承的是Comparable而不是Comparable。这意味着BigInteger和BiggerInteger是可以相互比较的�Q�这是非常好的。BiggerInteger可以重蝲compareTo()�Q�但是不允许实现一个不同的参数化的Comparable。这��是说BiggerInteger不能同时�l�承BigInteger和实现Comparable�?br />
当你使用可比较的对象�Ӟ��当写排序��法的时候）��C��两点。首先，使用原生�c�d��是不够充分的�Q�考虑到类型安全，必须指明同什么比较。接下来�Q�类型是不允许同自己比较的：有时候他会同他的��先比较。�ؓ了具体说明，考虑java.util.Collections.max()�Q?br />
�q�是一个冗长而且复杂的方法标�{�，我们来一步步考虑�Q?br /> �Ҏ��中包含一个类型变量T�Q��ƈ且有复杂的绑定，�E�后我们�q�回来讨论�?br /> �Ҏ��的返回值类型是T�?br /> �Ҏ��名是max()�?br />
�Ҏ��的参数是一个集合。元素的�c�d��指定为绑定的通配�W�。我们�ƈ不知道元素的��切�c�d��Q�但直到有一个上限T。所以我们知道元素的�c�d��要么为T�Q�要么是T的子�c�R��集合的��M��元素都可以作��回��g��用�?br />
�q�些是比较简单的�Q�本章我们已�l�看��C��通配�W�上界，我们再来看看max()中的�c�d��变量声明�Q?br />

>

要说明的�W�一点，T必须实现了Comparable接口。（范型的语法��用关键字extends来代表类型绑定，不论是类或接口）�q�是期望的，因�ؓ�q�个�Ҏ��是找到集合中最大的元素。但是观察这个参数化的Comparable接口�Q�这是一个通配�W�，但是�q�个通过关键字super来绑定，而不是extends。这是下界绑定�? extends T是我们熟悉的上界�l�定�Q�这意味着T或者其子类�? super T比较��用�Q�这意味着T或者他的超�c�R�?br />
�ȝ��一下，�c�d��变量声明表明�Q?#8220;T是一个实��C��Comparable接口或者他的父�c�d��C��该接口的�c�d��?#8221;Collections.min()和Collections.binarySearch()有着相同的声明�?br /> 对其他的下界通配�W�（对于Comparable接口没有作用�Q�的例子�Q�Collections中的addAll()�Q�copy()�Q�和fill()。观察addAll()的声明：

public static boolean addAll(Collection c, T... a)

�q�是一个varargs�Ҏ��Q�接受�Q意数量的参数�Q��ƈ且传递给他们一个T[]�Q�命名�ؓa。他��a中的所有元素都赋给集合c。集合的元素�c�d��虽然不知道，但是有一个下界：元素均�ؓT或者T的超�c�R��不论类型是什么，我们可以��定数组的元素都是类型的实例�Q�所以将数组的元素添加到集合中是合法的�?br />
�q�回到我们先前讨论的上界通配�W�，如果有一个集合的元素是上界通配�W�，那么都是只读的。考虑List。我们知道，所有的元素都是Serializable�Q�所以像get()�q�样的方法返回一个Serializable�c�d��的返回倹{��编译器不允许我们调用add()�q�样的方法，因�ؓ实际的元素类型是不可知的。不能够��d��l�对的Serializable对象到list中，因�ؓ实现他们的类可能不是正确的类型�?br />
既然上界�l�配�W�的�l�果是只�ȝ��Q�所以你可能会期望下界通配�W�来实现只写的集合。实际�ƈ不是�q�样�Q�假设这里有一个List。元素的实际�c�d��是不知道的，但是可能性是Integer或者他的祖先类Number和Object。无论实际类型是什么，��Integer�c�d��Q�而不是Number和Object对象�Q�的元素��d��到list中是安全的。无论实际类型是什么，list中所有元素都是Object对象的实例，所以list中像get()一��L��Ҏ��q�回Object�?br />
最后，让我们把注意力放到java.lang.Enum�c�R��Enum是所有枚丄��型的父类�Q�它实现了Comparable接口�Q�但是有一个让��惑的范型声明�Ҏ��Q?br />

public class Enum> implements Comparable, Serializable

�W�一��|��c�d��变量E的声明在一个��@环中。再仔细的看一看：声明真正说明了，Enum必须是一个本�w�就是Enum�c�d��的类型。这�U�表面上的��@环是很显然的�Q�如果我们看��C��implements子句。正如我们看到的�Q�Comparable�c�通常被定义�ؓ可以同自己比较的。而且他们的子�c�M��可以同他们的父类比较。从另一个方面将�Q�Enum实现了Comparable接口不是��Z��他本�w�，而是��Z��他的子类E�?br />

资源:
·Onjava.com:Onjava.com
·Matrix-Java开发者社�?http://www.matrix.org.cn/

Java, java, J2SE, j2se, J2EE, j2ee, J2ME, j2me, ejb, ejb3, JBOSS, jboss, spring, hibernate, jdo, struts, webwork, ajax, AJAX, mysql, MySQL, Oracle, Weblogic, Websphere, scjp, scjd Java中的泛型 �W�二部分

ammay 2009-12-14 22:55 发表评论

泛型�c�d��

ammay — Mon, 14 Dec 2009 14:53:00 GMT
泛型�c�d��Q�第一部分
作�? David Flanagan
��译�Q?a target="_new">cat

版权声明�Q�可以�Q意�{载，转蝲时请务必以超链接形式标明文章原始出处和作者信息及本声�?br /> 作�?
David Flanagan;cat
原文地址:
http://www.onjava.com/pub/a/onjava/excerpt/javaian5_chap04/index.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43864_Generic_Types.html
关键词： Generic Types

�~�辑按：《Java in a Nutshell, 5th Edition》覆盖了jdk5.0中很多变化和新特征，其中最重要的就是泛型。在本文的第一部分�Q�作者David Flanagan介绍了如何��用泛型；而在�W�二部分�Q�作者描�q�C��如何写你自己的泛型和泛型�Ҏ��?br />
Java5.0的新�Ҏ��之一是引入了泛型�c�d��和泛型方法。一个泛型类型通过使用一个或多个�c�d��变量来定义，�q�拥有一个或多个使用一个类型变量作��Z��个参数或者返回值的占位�W�。例如，�c�d��java.util.List是一个泛型类型：一个list�Q�其元素的类型被占位�W�E描述。这个类型有一个名为add()的方法，被声明�ؓ有一个类型�ؓE的参敎ͼ�同时�Q�有一个get()�Ҏ��Q�返回��D��声明为E�c�d��?br />
��Z��使用泛型�c�d��Q�你应该为类型变量详�l�指明实际的�c�d��Q��Ş成一个就像List�c�M��的参数化�c�d��。[1]指明�q�些额外的类型信息的原因是编译器据此能够在编译期为您提供很强的类型检查，增强您的�E�序的类型安全性。�D个例子来��_��您有一个只能保持String对象的List�Q�那么这�U�类型检查就能够��L��您往里面加入String[]对象。同��L��Q�增加的�c�d��信息使编译器能够为您做一些类型�{换的事情。比如，�~�译器知道了一个List有个get()�Ҏ��Q�其�q�回值是一个String对象�Q�因此您不再需要去��返回值由一个Object强制转换为String�?br />
Java.util包中的集合类在java5.0中已�l�被做成了泛型，也许您将会在您的�E�序中频�J�的使用��C��们。类型安全的集合�c�d��是一个泛型类型的典型案例。即便您从没有定义过您自��q��泛型�c�d��甚至从未用过除了java.util中的集合�c�M��外的泛型�c�d��Q�类型安全的集合�cȝ��好处也是极有意义的一个标志——他们证明了�q�个主要的新语言�Ҏ��的复杂性�?br />
我们从探索类型安全的集合�c�M��的基本的泛型用法开始，�q�而研�I�更多��用泛型类型的复杂�l�节。然后我们讨论类型参数通配�W�和有界通配�W�。描�l�了如何使用泛型以后�Q�我们阐明如何编写自��q��泛型�c�d��和泛型方法。我们对于泛型的讨论��结束于一��对于JavaAPI的核心中重要的泛型类型的旅行。这��旅�E�将探烦�q�些�c�d��以及他们的用法，旅程的目的是��Z��让您�Ҏ��型如何工作这个问题有个深入的理解�?br />
�c�d��安全集合�c?/span>

Java.util�c�d��包含了Java集合框架�Q�Java Collections Framework�Q�，�q�是一批包含对象的set、对象的list以及��Z��key-value的map。第五章��谈到集合类。这里，我们讨论的是在java5.0中集合类使用�c�d��参数来界定集合中的对象的�c�d��。这个讨论�ƈ不适合java1.4或更早期版本。如果没有泛型，对于集合�cȝ��使用需要程序员��C��每个集合中元素的�c�d��。当您在java1.4�U�创��Z��一个集合，您知道您攑օ�到集合中的对象的�c�d��Q�但是编译器不知道。您必须��心地往其中加入一个合适类型的元素�Q�当需要从集合中获取元素时�Q�您必须昑ּ�的写强制�c�d��转换以将他们从Object转换��Z��们真是的�c�d��。考察下边的java1.4的代码�?br />

public static void main(String[] args) {
    // This list is intended to hold only strings.
    // The compiler doesn't know that so we have to remember ourselves.
    List wordlist = new ArrayList();

    // Oops! We added a String[] instead of a String.
    // The compiler doesn't know that this is an error.
    wordlist.add(args);

    // Since List can hold arbitrary objects, the get() method returns
    // Object.  Since the list is intended to hold strings, we cast the
    // return value to String but get a ClassCastException because of
    // the error above.
    String word = (String)wordlist.get(0);
}

泛型�c�d��解决了这�D�代码中的显�C�的�c�d��安全问题。Java.util中的List或是其他集合�c�d��l��用泛型重写过了。就像前面提到的�Q?List被重新定义�ؓ一个list�Q�它中间的元素类型被一个类型可变的名称为E的占位符描述。Add()�Ҏ��被重新定义�ؓ期望一个类型�ؓE的参敎ͼ�用于替换以前的Object�Q�get()�Ҏ��被重新定义�ؓ�q�回一个E�Q�替换了以前的Object�?br />
在java5.0中，当我们申明一个List或者创��Z��个ArrayList的实例的时候，我们需要在泛型�c�d��的名字后面紧跟一�?#8220;<>”�Q�尖括号中写入我们需要的实际的类型。比如，一个保持String的List应该写成“List”。需要注意的是，�q�非常象�l�一个方法传一个参敎ͼ�区别是我们��用类型而不是��|��同时使用��括可��不是圆括号

Java.util的集合类中的元素必须是对象化的，他们不能是基本类型。泛型的引入�q�没有改变这炏V��泛型不能��用基本类型：我们不能�q�样来申明——Set或者List。记住，无论如何�Q�java5.0中的自动打包和自动解包特性��得��用Set或者List和直接��用char和int��g��h��ѝ��（查看�W�二章以了解更多关于自动打包和自动解包的�l�节�Q��?br />
在Java5.0中，上面的例子将被重写�ؓ如下方式�Q?br />

public static void main(String[] args) {
    // This list can only hold String objects
    List wordlist = new ArrayList();

    // args is a String[], not String, so the compiler won't let us do this
    wordlist.add(args);  // Compilation error!

    // We can do this, though.
    // Notice the use of the new for/in looping statement
    for(String arg : args) wordlist.add(arg);

    // No cast is required.  List.get() returns a String.
    String word = wordlist.get(0);
}

值得注意的是代码量其实�ƈ没有比原来那个没有泛型的例子��多��。��?#8220;(String)”�q�样的类型�{换被替换成了�c�d��参数“”�?不同的是�c�d��参数需要且仅需要声明一�ơ，而list能够被��用�Q何多�ơ，不需要类型�{换。在更长点的例子代码中，�q�一点将更加明显。即使在那些看上��L��型语法比非泛型语法要冗长的例子里�Q��用泛型依然是非常有�h值的——额外的�c�d��信息允许�~�译器在您的代码里执行更强的错误��查。以前只能在�q�行��h��能发现的错误现在能够在编译时��p��发现。此外，以前��Z��处理�c�d��转换的异常，我们需要添加额外的代码行。如果没有泛型，那么当发生类型�{换异常的时候，一个ClassCastException异常��׃��被从实际代码中抛出�?br />
��像一个方法可以��用�Q意数量的参数一��P��c�d��怋�用多个类型变量。接口Java.util.Map��是一个例子。一个Map体现了从一个key的对象到一个value的对象的映射关系。接口Map��x��了一个类型变量来描述key的类型而另一个类型变量来描述value的类型。�D个例子来��_��假设您希望做一个String对象到Integer对象的映��关�p�：

public static void main(String[] args) {
    // A map from strings to their position in the args[] array
    Map map = new HashMap();

    // Note that we use autoboxing to wrap i in an Integer object.
    for(int i=0; i < args.length; i++) map.put(args[i], i);

    // Find the array index of a word.  Note no cast is required!
    Integer position = map.get("hello");

    // We can also rely on autounboxing to convert directly to an int,
    // but this throws a NullPointerException if the key does not exist
    // in the map
    int pos = map.get("world");
}

象List�q�个一个参数类型其本��n也是也一个类型，也能够被用于当作其他�c�d��的一个类型变量倹{��您可能会看到这��L��代码�Q?br />

// Look at all those nested angle brackets!
Map>> map = getWeirdMap();

// The compiler knows all the types and we can write expressions
// like this without casting.  We might still get NullPointerException
// or ArrayIndexOutOfBounds at runtime, of course.
int value = map.get(key).get(0).get(0)[0];

// Here's how we break that expression down step by step.
List> listOfLists = map.get(key);
List listOfIntArrays = listOfLists.get(0);
int[] array = listOfIntArrays.get(0);
int element = array[0];

在上面的代码里，java.util.List和java.util.Map的get()�Ҏ��q�回一个类型�ؓE的list元素或者一个类型�ؓV的map元素。注意，无论如何�Q�泛型类型能够更�_�֯�的��用他们的变量。在本书中的参考章节查看List�Q�您��会看到它的iterator( )�Ҏ��被声明�ؓ�q�回一个Iterator。这意味着�Q�这个方法返回一个跟list的实际的参数�c�d��一��L��一个参数类型的实例。�ؓ了具体的说明�q�点�Q�下面的例子提供了不使用get(0)�Ҏ��来获取一个List的第一个元素的�Ҏ��?br />

List words = // ...initialized elsewhere...
Iterator iterator = words.iterator();
String firstword = iterator.next();

理解泛型�c�d��

本段��对泛型�c�d��的��用细节做�q�一步的探讨�Q�以��试说明下列问题�Q?br /> 不带�c�d��参数的��用泛型的后果
参数化类型的体系
一个关于编译期泛型�c�d��的类型安全的漏洞和一个用于确保运行期�c�d��安全的补�?br /> ��Z��么参数化�c�d��的数�l�不是类型安全的

未经处理的类型和不被��查的警告
即��被重写的Java集合�c�d��来了泛型的好处，在��用他们的时候您也不被要求说明类型变量。一个不带类型变量的泛型�c�d��被认为是一个未�l�处理的�c�d��Q�raw type�Q�。这��P��5.0版本以前的java代码仍然能够�q�行�Q�您昑ּ�的编写所有类型�{换就像您已经�q�样写的一��P��您可能会被一些来自编译器的麻烦所困扰。查看下列存储不同类型的对象��C��个未�l�处理的List�Q?br />

List l = new ArrayList();
l.add("hello");
l.add(new Integer(123));
Object o = l.get(0);

�q�段代码在java1.4下运行得很好。如果您用java5.0来编译它�Q�javac�~�译了，但是会打印出�q�样�?#8220;抱�?#8221;�Q?br />
Note: Test.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

如果我们加入-Xlint参数后重新编译，我们会看到这些警告：

Test.java:6: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add("hello");
         ^
Test.java:7: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add(new Integer(123));
         ^
�~�译在add()�Ҏ��的调用上�l�出了警告，因�ؓ它不能够��信加入到list中的值具有正��的�c�d��。它告诉我们说我们��用了一个未�l�处理的�c�d��Q�它不能验证我们的代码是�c�d��安全的。注意，get()�Ҏ��的调用是没有问题的，因�ؓ能够被获得的元素已经安全的存在于list中了�?br />
如果您不想��用�Q何的java5.0的新�Ҏ��，您可以简单的通过�?source1.4标记来编译他们，�q�样�~�译器就不会�?#8220;抱�?#8221;了。如果您不能�q�样做，您可以忽略这些警告，通过使用一�?#8220;@SuppressWarnings("unchecked")”注解�Q�查看本章的4.3节）隐瞒�q�些警告信息或者升�U�您的代码，加入�c�d��变量描述。[2]下列�C�Z��代码�Q�编译的时候不再会有警告但仍然允许您往list中放入不同的�c�d��的对象�?br />

List l = new ArrayList();
l.add("hello");
l.add(123);              // autoboxing
Object o = l.get(0);

参数化类型的体系

参数化类型有�c�d��体系�Q�就像一般的�c�d��一栗��这个体�p�d��于对象的�c�d��Q�而不是变量的�c�d��。这里有些例子您可以��试�Q?br />

ArrayList l = new ArrayList();
List m = l;                            // okay
Collection n = l;                      // okay
ArrayList o = l;                        // error
Collection p = (Collection)l;   // error, even with cast

一个List是一个Collection�Q�但不是一个List。这句话不容易理解，如果您想理解��Z��么泛型这样做�Q�这�D�值得看一下。考察�q�段代码�Q?br />

List li = new ArrayList();
li.add(123);

// The line below will not compile.  But for the purposes of this
// thought-experiment, assume that it does compile and see how much
// trouble we get ourselves into.
List lo = li;

// Now we can retrieve elements of the list as Object instead of Integer
Object number = lo.get(0);

// But what about this?
lo.add("hello world");

// If the line above is allowed then the line below throws ClassCastException
Integer i = li.get(1);  // Can't cast a String to Integer!

�q�就是�ؓ什么List不是一个List的原因，虽然List中所有的元素事实上是一个Object的实例。如果允许�{换成List�Q�那么�{换后�Q�理��Z��非整型的对象也将被允许添加到list中�?br />
�q�行时类型安�?/span>

��像我们所见到的，一个List不允许被转换��Z��个List�Q�即使这个X能够被�{换�ؓY。然而，一个List能够被�{换�ؓ一个List�Q�这��h��可以通过�l�承的方法来做这��L��事情�?br /> �q�种��参数化�c�d��转换为非参数化类型的能力对于向下兼容是必要的�Q�但是它会在泛型所带来的类型安全体�p�M��凿个漏洞�Q?br />

// Here's a basic parameterized list.
List li = new ArrayList();

// It is legal to assign a parameterized type to a nonparameterized variable
List l = li;

// This line is a bug, but it compiles and runs.
// The Java 5.0 compiler will issue an unchecked warning about it.
// If it appeared as part of a legacy class compiled with Java 1.4, however,
// then we'd never even get the warning.
l.add("hello");

// This line compiles without warning but throws ClassCastException at runtime.
// Note that the failure can occur far away from the actual bug.
Integer i = li.get(0);

泛型仅提供了�~�译期的�c�d��安全。如果您使用java5.0的编译器来编译您的代码�ƈ且没有得��C�Q何警告，�q�些�~�译器的��查能够确保您的代码在�q�行期也是类型安全的。如果您获得了警告或者��用了像未�l�处理的�c�d��那样修改您的集合的代码，那么您需要增加一些步骤来��保�q�行期的�c�d��安全。您可以通过使用java.util.Collections中的checkedList()和checkedMap( )�Ҏ��来做到这一步。这些方法将把您的集合打包成一个wrapper集合�Q�从而在�q�行时检查确认只有正��类型的��D��够被�|�入集合众。下面是一个能够补上类型安全漏�z�的一个例子：

// Here's a basic parameterized list.
List li = new ArrayList();

// Wrap it for runtime type safety
List cli = Collections.checkedList(li, Integer.class);

// Now widen the checked list to the raw type
List l = cli;

// This line compiles but fails at runtime with a ClassCastException.
// The exception occurs exactly where the bug is, rather than far away
l.add("hello");

参数化类型的数组

在��用泛型类型的时候，数组需要特别的考虑。回忆一下，如果T是S的父�c�（或者接口）�Q�那么类型�ؓS的数�l�S[]�Q�同时又是类型�ؓT的数�l�T[]。正因�ؓ如此�Q�每�ơ您存放一个对象到数组中时�Q�Java解释器都必须�q�行��查以��保您放入的对象�c�d��与要存放的数�l�所允许的类型是匹对的。例如，下列代码在运行期会检查失败，抛出一个ArrayStoreException异常�Q?br />

String[] words = new String[10];
Object[] objs = words;
objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

虽然�~�译时obj是一个Object[]�Q�但是在�q�行时它是一个String[]�Q�它不允许被用于存放一个Integer.
当我们��用泛型类型的时候，仅仅依靠�q�行时的数组存放异常��查是不够的，因�ؓ一个运行时�q�行的检查�ƈ不能够获取编译时的类型参��C��息。查看下列代码：

List[] wordlists = new ArrayList[10];
ArrayList ali = new ArrayList();
ali.add(123);
Object[] objs = wordlists;
objs[0] = ali;                       // No ArrayStoreException
String s = wordlists[0].get(0);      // ClassCastException!

如果上面的代码被允许�Q�那么运行时的数�l�存储检查将会成功：没有�~�译时的�c�d��参数�Q�代码简单地存储一个ArrayList��C��个ArrayList[]数组�Q�非常正��。既然编译器不能��L��您通过�q�个�Ҏ��来战胜类型安全，那么它�{而阻止您创徏一个参数化�c�d��的数�l�。所以上�q�情节永�q�不会发生，�~�译器在�W�一行就开始拒�l�编译了�?br />
注意�q��ƈ不是一个在使用数组时��用泛型的全部的约束，�q�仅仅是一个创��Z��个参数化�c�d��数组的约束。我们将在学习如何写泛型�Ҏ��时再来讨��个话题�?br />

�c�d��参数通配�W?/span>
假设我们需要写一个方法来昄��一个List中的元素。[3]在以前，我们只需要象�q�样写段代码�Q?br />

public static void printList(PrintWriter out, List list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}

在Java5.0中，List是一个泛型类型，如果我们试图�~�译�q�个�Ҏ��Q�我们将会得到unchecked警告。�ؓ了解册��些警告，您可能需要这��h��修改�q�个�Ҏ��Q?br />

public static void printList(PrintWriter out, List list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}

�q�段代码能够�~�译通过同时不会有警告，但是它�ƈ不是非常地有效，因�ؓ只有那些被声明�ؓList的list才会被允�怋�用这个方法。还记得么，�c�M��于List和List�q�样的List�q�不能被转型为List。事实上我们需要一个类型安全的printList()�Ҏ��Q�它能够接受我们传入的�Q何List�Q�而不兛_��它被参数化�ؓ什么。解军_��法是使用�c�d��参数通配�W�。方法可以被修改成这��P��

public static void printList(PrintWriter out, List list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        Object o = list.get(i);
        out.print(o.toString());
    }
}

�q�个版本的方法能够被�~�译�q�，没有警告�Q�而且能够在�Q何我们希望��用的地方使用。通配�W?#8220;�Q?#8221;表示一个未知类型，�c�d��List被读�?#8220;List of unknown”
作�ؓ一般原则，如果�c�d��是泛型的�Q�同时您�q�不知道或者�ƈ不关心值的�c�d��Q�您应该使用“?”通配�W�来代替一个未�l�处理的�c�d��。未�l�处理的�c�d��被允�总�是�ؓ了向下兼容，而且应该只能够被允许出现在老的代码中。注意，无论如何�Q�您不能在调用构造器时��用通配�W�。下面的代码是非法的�Q?br /> List l = new ArrayList();

创徏一个不知道�c�d��的List是毫无道理的。如果您创徏了它�Q�那么您必须知道它将保持的元素是什么类型的。您可以在随后的�Ҏ��中不兛_��元素�c�d��而去遍历�q�里list�Q�但是您需要在您创建它的时候描�q�元素的�c�d��。如果你��实需要一个List来保持�Q何类型，那么您只能这么写�Q?br />

List l = new ArrayList();

从上面的printList()例子中，必须要搞清楚List<�Q?gt;既不是List也不是一个未�l�处理的List。一个��用通配�W�的List有两个重要的�Ҏ��。第一�Q�考察�c�M��于get()的方法，他们被声明返回一个��|��q�个值的�c�d��是类型参��C��指定的。在�q�个例子中，�c�d��?#8220;unknown”�Q�所以这些方法返回一个Object。既然我们期望的是调用这个object的toString()�Ҏ��Q�程序能够很好的满��我们的意�ѝ�?br />
�W�二�Q�考察List的类似add()的方法，他们被声明�ؓ接受一个参敎ͼ��q�个参数被类型参数所定义。出人意料的是，当类型参数是未确定的�Q�编译器不允许您调用��M��有不��定参数�c�d��的方法——因为它不能��认您传入了一个恰当的倹{��一个List(�Q?实际上是只读的——既然编译器不允许我们调用类��g��add(),set(),addAll()�q�类的方法�?br />
界定通配�W?/span>
让我们在我们原来的例子上作些��小的稍微复杂一点的改动。假设我们希望写一个sumList()�Ҏ��来计��list中Number�c�d��的值的合计。在以前�Q�我们��用未�l�处理的List�Q�但是我们不��x��弃类型安全，同时不得不处理来自编译器的unchecked警告。或者我们可以��用List�Q�那��L��话我们就不能调用List、List中的�Ҏ��了，而事实上我们需要调用。如果我们��用通配�W�，那么我们实际上不能得到我们期望的�c�d��安全�Q�我们不能确定我们的�Ҏ��被什么样的List所调用�Q�Number�Q�还是Number的子�c�？甚至�Q�String?�q�样的一个方法也�怼�被写成这��P��

public static double sumList(List list) {
    double total = 0.0;
    for(Object o : list) {
        Number n = (Number) o;  // A cast is required and may fail
        total += n.doubleValue();
    }
    return total;
}

要修改这个方法让它变得真正的�c�d��安全�Q�我们需要��用界定通配�W�（bounded wildcard�Q�，能够��保List的类型参数是未知的，但又是Number或者Number的子�c�R��下面的代码才是我们惌��的：

public static double sumList(List list) {
    double total = 0.0;
    for(Number n : list) total += n.doubleValue();
    return total;
}

�c�d��List可以被理解�ؓ“Number未知子类的List”。理解这炚w��帔R��要，在这�D�|��字中�Q�Number被认为是其自�w�的子类�?br />
注意�Q�这��L��话，那些�c�d��转换已经不再需要了。我们�ƈ不知道list中元素的具体�c�d��Q�但是我们知道他们能够向上�{型�ؓNumber�Q�因此我们可以把他们从list中把他们当作一个Number对象取出。��用一个for/in循环能够�E�微��装一下从list中取出元素的�q�程。普遍性的原则是当您��用一个界定通配�W�时�Q�类��g��List中的get()�Ҏ��的那些方法将�q�回一个类型�ؓ上界的倹{��因此如果我们在for/in循环中调用list.get()�Q�我们将得到一个Number。在前一节说��C��用通配�W�时�c�M��于list.add()�q�种�Ҏ��中的限制依然有效�Q��D个例子来��_��如果�~�译器允许我们调用这�c�L��法，我们��可以将一个Integer攑ֈ�一个声明�ؓ仅保持Short值的list中去�?br />
同样可行的是使用下界通配�W�，不同的是用super替换extends。这个技巧在被调用的�Ҏ��上有一点不同的作用。在实际应用中，下界通配�W�要比上界通配�W�用得少。我们将在后面的章节里讨��个问题�?br />

脚注
[1] 在本章中�Q�我会坚持用术语”泛型�c�d��”来指一个声明一个或多个�c�d��变量的类型，�?#8221;参数化的�c�d��”来指由实际类型参数来替换其类型变量的泛型�c�d��。然而，在一般情况下�Q�这�U�区别�ƈ不明显，�q�且�q�些术语有时通用�?br /> [2] 在撰写本文时候，javac�q�不支持@SuppressWarnings 的注解。期望在Java 5.1中得到支持�?
[3] 本节所�C�的3个printList()�Ҏ��忽略了这样一个事实，即java.util 中List的所有实现类都有一个可用的toString()�Ҏ��。还要注意这些方法假定List实现RandomAccess�q�在LinkedList实例中只提供了很差的�q�行效率�?br /> David Flanagan是众多O'Reilly书籍的作者。这些书包括《Java in a Nutshell》，《Java Examples in a Nutshell》，《Java Foundation Classes in a Nutshell》，《JavaScript: The Definitive Guide》，《JavaScript Pocket Reference》�?br />
在Java in a Nutshell, 5th Edition中查看目录信息�?br />

ammay 2009-12-14 22:53 发表评论

泛型

ammay — Mon, 14 Dec 2009 14:52:00 GMT

泛型�?Sun 公司发布�?JDK 5.0 中的一个重要特性，它的最大优�Ҏ��提供了程序的�c�d��安全同可以向后兼宏V��ؓ了帮助读者更好地理解和��用泛型，本文通过一些示例从基本原理�Q�重要概念，关键技术，以及�怼�技术比较等多个角度�?Java 语言中的泛型技术进行了介绍�Q�重点强调了泛型中的一些基本但又不是很好理解的概念�?/p>
��Z��避免�?C++ 中的模板��h��Q�本文简要介�l�了 Java 中的泛型�?C++ 中的模板的主要区别，希望�q�种比较能够帮助读者加深对泛型的理解�?/p>

引言

很多 Java �E�序员都使用�q�集合（Collection�Q�，集合中元素的�c�d��是多�U�多��L��Q�例如，有些集合中的元素�?Byte �c�d��的，而有些则可能�?String �c�d��的，�{�等。Java 语言之所以支持这么多�U�类的集合，是因为它允许�E�序员构��Z��个元素类型�ؓ Object �?Collection�Q�所以其中的元素可以是�Q何类型�?/p>
当��?Collection �Ӟ��我们�l�常要做的一件事情就是要�q�行�c�d��转换�Q�当转换成所需的类型以后，再对它们�q�行处理。很明显�Q�这�U�设计给�~�程人员带来了极大的不便�Q�同时也�Ҏ��引入错误�?/p>
在很�?Java 应用中，上述情况非常普遍�Q��ؓ了解册��个问题，�?Java 语言变得更加安全好用�Q�近些年的一些编译器�?Java 语言�q�行了扩充，�?Java 语言支持�?泛型"�Q�特别是 Sun 公司发布�?JDK 5.0 更是��泛型作为其中一个重要的�Ҏ��加以推�qѝ�?/p>
本文首先�Ҏ��型的基本概念和特点进行简单介�l�，然后通过引入几个实例来讨论带有泛型的�c�，泛型中的子类型，以及范化�Ҏ��和受限类型参数等重要概念。�ؓ了帮助读者更加深�ȝ��理解�q��用泛型，本文�q�介�l�了泛型的�{化，卻I��如何��带有泛型的 Java �E�序转化成一般的没有泛型�?Java �E�序。这��P��读者对泛型的理解就不会仅仅局限在表面上了。考虑到多数读者仅仅是使用泛型�Q�因此本文�ƈ未介�l�泛型在�~�译器中的具体实现。Java 中的泛型�?C++ 中的模板表面上非常相��|��但实际上二者还是有很大区别的，本文最后简单介�l�了 Java 中的泛型�?C++ 模板的主要区别�?/p>

回页�?/strong>

泛型概览

泛型本质上是提供�c�d��?�c�d��参数"�Q�它们也被称为参数化�c�d��Q�parameterized type�Q�或参量多态（parametric polymorphism�Q�。其实泛型思想�q�不�?Java 最先引入的�Q�C++ 中的模板��是一个运用泛型的例子�?/p>
GJ�Q�Generic Java�Q�是�?Java 语言的一�U�扩展，是一�U�带有参数化�c�d��?Java 语言。用 GJ �~�写的程序看��h��和普通的 Java �E�序基本相同�Q�只不过多了一些参数化的类型同时少了一些类型�{换。实际上�Q�这�?GJ �E�序也是首先被�{化成一般的不带泛型�?Java �E�序后再�q�行处理的，�~�译器自动完成了�?Generic Java 到普�?Java 的翻译。具体的转化�q�程大致分�ؓ以下几个部分�Q?/p>

��参数化�c�d��中的�c�d��参数"擦除"�Q�erasure�Q�掉�Q?
��类型变量用"上限�Q�upper bound�Q?取代�Q�通常情况下这些上限是 Object。这里的�c�d��变量是指实例域，本地�Ҏ��域，�Ҏ��参数以及�Ҏ��q�回��g��用来标记�c�d��信息�?变量"�Q�例如：实例域中的变量声�?A elem;�Q�方法声�?Node (A elem){};�Q�其中，A 用来标记 elem 的类型，它就是类型变量�?
��d��c�d��转换�q�插�?桥方�?�Q�bridge method�Q�，以便覆盖�Q�overridden�Q�可以正常的工作�?

转化后的�E�序和没有引入泛型时�E�序员不得不手工完成转换的程序是非常一致的�Q�具体的转化�q�程会在后面介绍。GJ 保持了和 Java 语言以及 Java 虚拟机很好的兼容性，下面�?GJ 的特点做一个简要的�ȝ��?/p>

�c�d��安全�?泛型的一个主要目标就是提�?Java �E�序的类型安全。��用泛型可以�ɾ~�译器知道变量的�c�d��限制�Q�进而可以在更高�E�度上验证类型假设。如果没有泛型，那么�c�d��的安全性主要由�E�序员来把握�Q�这昄��不如带有泛型的程序安全性高�?
消除强制�c�d��转换。泛型可以消除源代码中的许多强制�c�d��转换�Q�这样可以��代码更加可读�Q��ƈ减少出错的机会�?
向后兼容。支持泛型的 Java �~�译器（例如 JDK5.0 中的 Javac�Q�可以用来编译经�q�泛型扩充的 Java �E�序�Q�GJ �E�序�Q�，但是现有的没有��用泛型扩充的 Java �E�序仍然可以用这些编译器来编译�?
层次清晰�Q�恪守规范。无��~�译的源�E�序是否使用泛型扩充�Q�编译生成的字节码均可被虚拟机接受�ƈ执行。也��是说不��编译器的输入是 GJ �E�序�Q�还是一般的 Java �E�序�Q�经�q�编译后的字节码都严格遵循《Java 虚拟��范》中对字节码的要求。可见，泛型主要是在�~�译器层面实现的�Q�它对于 Java 虚拟机是透明的�?
性能收益。目前来�Ԍ��?GJ �~�写的代码和一般的 Java 代码在效率上是非常接�q�的�?但是�׃��泛型会给 Java �~�译器和虚拟机带来更多的�c�d��信息�Q�因此利用这些信息对 Java �E�序做进一步优化将成�ؓ可能�?

以上是泛型的一些主要特点，下面通过几个相关的例子来�?Java 语言中的泛型�q�行说明�?/p>

回页�?/strong>

带有泛型的类

��Z��帮助大家更好地理�?Java 语言中的泛型�Q�我们在�q�里先来�Ҏ��两段实现相同功能�?GJ 代码�?Java 代码。通过观察它们的不同点来对 Java 中的泛型有个��M��的把握，首先来分析一下不带泛型的 Java 代码�Q�程序如下：

1 interface Collection { 2 public void add (Object x); 3 public Iterator iterator (); 4 } 5 6 interface Iterator { 7 public Object next (); 8 public boolean hasNext (); 9 } 10 11 class NoSuchElementException extends RuntimeException {} 12 13 class LinkedList implements Collection { 14 15 protected class Node { 16 Object elt; 17 Node next = null; 18 Node (Object elt) { this.elt = elt; } 19 } 20 21 protected Node head = null, tail = null; 22 23 public LinkedList () {} 24 25 public void add (Object elt) { 26 if (head == null) { head = new Node(elt); tail = head; } 27 else { tail.next = new Node(elt); tail = tail.next; } 28 } 29 30 public Iterator iterator () { 31 32 return new Iterator () { 33 protected Node ptr = head; 34 public boolean hasNext () { return ptr != null; } 35 public Object next () { 36 if (ptr != null) { 37 Object elt = ptr.elt; ptr = ptr.next; return elt; |-------10--------20--------30--------40--------50--------60--------70--------80--------9| |-------- XML error: The previous line is longer than the max of 90 characters ---------| 38 } else throw new NoSuchElementException (); 39 } 40 }; 41 } 42 }

接口 Collection 提供了两个方法，��x��加元素的�Ҏ�� add(Object x)�Q�见�W?2 行，以及�q�回�?Collection �?Iterator 实例的方�?iterator()�Q�见�W?3 行�?code>Iterator 接口也提供了两个�Ҏ��Q�其一��是判断是否有下一个元素的�Ҏ�� hasNext()�Q�见�W?8 行，另外��是�q�回下一个元素的�Ҏ�� next()�Q�见�W?7 行�?code>LinkedList �c�L��Ҏ��?Collection 的实玎ͼ�它是一个含有一�p�d��节点的链表，节点中的数据�c�d��?Object�Q�这样就可以创徏��L��c�d��的节点了�Q�比�?Byte�Q?String �{�等。上面这�D늨�序就是用没有泛型的传�l�的 Java 语言�~�写的代码。接下来我们分析一下传�l�的 Java 语言是如何��用这个类的�?/p>
代码如下�Q?/p>

1 class Test { 2 public static void main (String[] args) { 3 // byte list 4 LinkedList xs = new LinkedList(); 5 xs.add(new Byte(0)); xs.add(new Byte(1)); 6 Byte x = (Byte)xs.iterator().next(); 7 // string list 8 LinkedList ys = new LinkedList(); 9 ys.add("zero"); ys.add("one"); 10 String y = (String)ys.iterator().next(); 11 // string list list 12 LinkedList zss = new LinkedList(); 13 zss.add(ys); 14 String z = (String)((LinkedList)zss.iterator().next()).iterator().next(); |-------10--------20--------30--------40--------50--------60--------70--------80--------9| |-------- XML error: The previous line is longer than the max of 90 characters ---------| 15 // string list treated as byte list 16 Byte w = (Byte)ys.iterator().next(); // run-time exception 17 } 18 }

从上面的�E�序我们可以看出�Q�当从一个链表中提取元素旉��要进行类型�{换，�q�些都要��q��序员昑ּ�地完成。如果我们不��心�?String �c�d��的链表中试图提取一�?Byte 型的元素�Q�见�W?15 到第 16 行的代码�Q�那么这��会抛出一个运行时的异常。请注意�Q�上面这�D늨�序可以顺利地�l�过�~�译�Q�不会��生�Q何编译时的错误，因�ؓ�~�译器�ƈ不做�c�d��查，�q�种��查是在运行时�q�行的。不隑֏�玎ͼ�传统 Java 语言的这一�~�陷推迟了发现程序中错误的时��_��从��Y件工�E�的角度来看�Q�这对��Y件的开发是非常不利的。接下来�Q�我们讨��Z��下如何用 GJ 来实现同样功能的�E�序。源�E�序如下�Q?/p>

1 interface Collection { 2 public void add(A x); 3 public Iterator iterator(); 4 } 5 6 interface Iterator { 7 public A next(); 8 public boolean hasNext(); 9 } 10 11 class NoSuchElementException extends RuntimeException {} 12 13 class LinkedList implements Collection { 14 protected class Node { 15 A elt; 16 Node next = null; 17 Node (A elt) { this.elt = elt; } 18 } 19 20 protected Node head = null, tail = null; 21 22 public LinkedList () {} 23 24 public void add (A elt) { 25 if (head == null) { head = new Node(elt); tail = head; } 26 else { tail.next = new Node(elt); tail = tail.next; } 27 } 28 29 public Iterator iterator () { 30 return new Iterator () { 31 protected Node ptr = head; 32 public boolean hasNext () { return ptr != null; } 33 public A next () { 34 if (ptr != null) { 35 A elt = ptr.elt; ptr = ptr.next; return elt; |-------10--------20--------30--------40--------50--------60--------70--------80--------9| |-------- XML error: The previous line is longer than the max of 90 characters ---------| 36 } else throw new NoSuchElementException (); 37 } 38 }; 39 } 40 }

�E�序的功能�ƈ没有��M��改变�Q�只是在实现方式上��用了泛型技术。我们注意到上面�E�序的接口和�c�d��带有一个类型参�?A�Q�它被包含在一对尖括号�Q?lt; >�Q�中�Q�见�W?1�Q? �?13 行，�q�种表示法遵循了 C++ 中模板的表示习惯。这部分�E�序和上面程序的主要区别��是�?Collection, Iterator, �?LinkedList 出现的地方均�?Collection, Iterator, �?LinkedList 来代替，当然�Q�第 22 行对构造函数的声明除外�?/p>
下面再来分析一下在 GJ 中是如何对这个类�q�行操作的，�E�序如下�Q?/p>

1 class Test { 2 public static void main (String [] args) { 3 // byte list 4 LinkedList xs = new LinkedList(); 5 xs.add(new Byte(0)); xs.add(new Byte(1)); 6 Byte x = xs.iterator().next(); 7 // string list 8 LinkedList ys = new LinkedList(); 9 ys.add("zero"); ys.add("one"); 10 String y = ys.iterator().next(); 11 // string list list 12 LinkedList>zss= newLinkedList>(); 13 zss.add(ys); 14 String z = zss.iterator().next().iterator().next(); 15 // string list treated as byte list 16 Byte w = ys.iterator().next(); // compile-time error 17 } 18 }

在这里我们可以看刎ͼ�有了泛型以后�Q�程序员�q�不需要进行显式的�c�d��转换�Q�只要赋予一个参数化的类型即可，见第 4�Q? �?12 行，�q�是非常方便的，同时也不会因为忘记进行类型�{换而��生错误。另外需要注意的��是当试图从一个字�W�串�c�d��的链表里提取��Z��个元素，然后��它赋值给一�?Byte 型的变量�Ӟ��见第 16 行，�~�译器将会在�~�译时报出错误，而不是由虚拟机在�q�行时报错，�q�是因�ؓ�~�译器会在编译时��d�� GJ 代码�q�行�c�d��查，此种机制有利于尽早地发现�q�改正错误�?/p>
�c�d��参数的作用域是定义这个类型参数的整个�c�，但是不包括静态成员函数。这是因为当讉K��同一个静态成员函数时�Q�同一个类的不同实例可能有不同的类型参敎ͼ�所以上�q�提到的那个作用域不应该包括�q�些静态函敎ͼ�否则��׃��引�v混�ؕ�?/p>

回页�?/strong>

泛型中的子类�?/span>

�?Java 语言中，我们可以��某�U�类型的变量赋值给其父�c�d��所对应的变量，例如�Q�String �?Object 的子�c�d��Q�因此，我们可以��?String �c�d��的变量赋值给 Object �c�d��的变量，甚至可以��?String [ ] �c�d��的变量（数组�Q�赋值给 Object [ ] �c�d��的变量，�?String [ ] �?Object [ ] 的子�c�d��?/p>
上述情�Ş恐怕已�l�深深地印在了广大读者的脑中�Q�对于泛型来�Ԍ��上述情�Ş有所变化�Q�因此请�q�大读者务必引��h��意。�ؓ了说明这�U�不同，我们�q�是先来分析一个小例子�Q�代码如下所�C�：

1 List ls = new ArrayList(); 2 List lo = ls; 3 lo.add(new Integer()); 4 String s = ls.get(0);

上述代码的第二行��?List 赋值给�?List�Q�按照以往的经验，�q�种赋值好像是正确的，因�ؓ List 应该�?List 的子�c�d��。这里需要特别注意的是，�q�种赋值在泛型当中是不允许的！List 也不�?List 的子�c�d��?/p>
如果上述赋值是合理的，那么上面代码的第三行的操作将是可行的�Q�因�?lo �?List�Q�所以向其添�?Integer �c�d��的元素应该是完全合法的。读到此处，我们已经看到了第二行的这�U�赋值所潜在的危险，它破坏了泛型所带来的类型安全性�?/p>
一般情况下�Q�如�?A �?B 的子�c�d��Q�C 是某个泛型的声明�Q�那�?C �q�不�?C 的子�c�d��Q�我们也不能��?C �c�d��的变量赋值给 C �c�d��的变量。这一点和我们以前接触的父子类型关�p�L��很大的出入，因此误��者务必引��h��意�?/p>

回页�?/strong>

泛化�Ҏ��和受限类型参�?/span>

在这一部分我们��讨论有��x��化方法（generic method �Q�和受限�c�d��参数�Q�bounded type parameter�Q�的内容�Q�这是泛型中的两个重要概念，�q�是先来分析一下与此相关的代码�?/p>

1 interface Comparable { 2 public int compareTo(A that); 3 } 4 5 class Byte implements Comparable { 6 private byte value; 7 public Byte(byte value) {this.value = value;} 8 public byte byteValue() {return value;} 9 public int compareTo(Byte that) { 10 return this.value - that.value; 11 } 12 } 13 14 class Collections { 15 public static > 16 A max (Collection xs) { 17 Iterator xi = xs.iterator(); 18 A w = xi.next(); 19 while (xi.hasNext()) { 20 A x = xi.next(); 21 if (w.compareTo(x) < 0) w = x; 22 } 23 return w; 24 } 25 }

�q�里定义了一个接�?Comparable�Q�用来和 A �c�d��的对象进行比较。类 Byte 实现了这个接口，�q�以它自�׃��为类型参敎ͼ�因此�Q�它们自己就可以和自��p��行比较了�?/p>
�W?14 行到�W?25 行的代码定义了一个类 Collections�Q�这个类包含一个静态方�?max(Collection xs)�Q�它用来在一个非�I�的 Collection 中寻找最大的元素�q�返回这个元素。这个方法的两个特点��是它是一个泛化方法�ƈ且有一个受限类型参数�?/p>
之所以说它是泛化了的�Ҏ��Q�是因�ؓ�q�个�Ҏ��可以应用到很多种�c�d��上。当要将一个方法声明�ؓ泛化�Ҏ��Ӟ��我们只需要在�q�个�Ҏ��的返回类型（A�Q�之前加上一个类型参敎ͼ�A�Q�，�q�用��括��P��< >�Q�将它括��h��。这里的�c�d��参数�Q�A�Q�是在方法被调用时自动实例化的。例如，假设对象 m 的类型是 Collection�Q�那么当使用下面的语句：

Byte x = Collections.max(m);

调用�Ҏ�� max �Ӟ��该方法的参数 A ��被推测�?Byte�?/p>
�Ҏ��上面讨论的内容，泛化�Ҏ�� max 的完整声明应该是下面的�Ş式：

< A > A max (Collection xs) { max 的方法体 }

但是�Q�我们见到的 max �?< A > 中还多了 "implements Comparable " 一��，�q�是什么呢�Q�这��是我们下面��要谈到�?受限的类型参�?。在上面的例子中�Q�类型参�?A ��是一个受限的的类型参敎ͼ�因�ؓ它不是泛指�Q何类型，而是指那些自己和自己作比较的�c�d��。例如参数可以被实例化�ؓ Byte�Q�因为程序中�?Byte implements Comparable 的语句，参见�W?5 行。这�U�限�Ӟ��或者说是范��_��通过如下的方式表�C�，"�c�d��参数 implements 接口"�Q�或�?"�c�d��参数 extend �c?�Q�上面程序中�?Byte implements Comparable"��是一例�?/p>

回页�?/strong>

泛型的�{�?/span>

在前面的几部分内容当中，我们介绍了有��x��型的基础知识�Q�到此读者对 Java 中的泛型技术应该有了一定的了解�Q�接下来的这部分内容��讨论有��x��型的转化�Q�即如何��带有泛型的 Java 代码转化成一般的没有泛型 Java 代码。其实在前面的部分里�Q�我们或多或��地也提��C��一些相关的内容�Q�下面再来详�l�地介绍一下�?/p>
首先需要明��的一�Ҏ��上面所讲的�q�种转化�q�程是由�~�译器（例如�Q�Javac�Q�完成的�Q�虚拟机�q�不负责完成�q�一��d��。当�~�译器对带有泛型�?Java 代码�q�行�~�译�Ӟ��它会��L��行类型检查和�c�d��推断�Q�然后生成普通的不带泛型的字节码�Q�这�U�字节码可以被一般的Java虚拟机接收�ƈ执行�Q�这�U�技术被�U�Cؓ擦除�Q�erasure�Q��?/p>
可见�Q�编译器可以在对源程序（带有泛型�?Java 代码�Q�进行编译时使用泛型�c�d��信息保证�c�d��安全�Q�对大量如果没有泛型��׃��会去验证的类型安全约束进行验证，同时在生成的字节码当中，��这些类型信息清除掉�?/p>
对于不同的情况，擦除技术所执行�?擦除"动作是不同的�Q�主要分��Z��下几�U�情况：

对于参数化类型，需要删除其中的�c�d��参数�Q�例如，LinkedList ��被"擦除"�?LinkedList�Q?/code>
对于非参数化�c�d��Q�不作擦除，或者说用它自己来擦除自己，例如 String ��被"擦除"�?String�Q?
对于�c�d��变量�Q�有关类型变量的说明请参�?泛型概览"相关内容�Q�，要用它们的上限来对它们进行替换。多数情况下�q�些上限�?Object�Q�但是也有例外，后面的部分将会对此进行介�l��?
除此之外�Q�还需要注意的一�Ҏ��Q�在某些情况下，擦除技术需要引入类型�{换（cast�Q�，�q�些情况主要包括�Q?/p> 情况 1. �Ҏ��的返回类型是�c�d��参数�Q?/p> 情况 2. 在访问数据域�Ӟ��域的�c�d��是一个类型参数�?/p> 例如在本�?带有泛型的类"一��节的最后，我们�l�出了一�D�|��试程序，一�?Test �c�R��这个类包含以下几行代码�Q?/p> 8 LinkedList ys = new LinkedList(); 9 ys.add("zero"); ys.add("one"); 10 String y = ys.iterator().next(); �q�部分代码�{换后��变成了如下的代码： 8 LinkedList ys = new LinkedList(); 9 ys.add("zero"); ys.add("one"); 10 String y = (String)ys.iterator().next(); �W?10 行的代码�q�行了类型�{换，�q�是因�ؓ在调�?next() �Ҏ��Ӟ��~�译器发现该�Ҏ��的返回值类型是�c�d��参数 A�Q�请参见�Ҏ��?next() 的定义）�Q�因此根据上面提到的情况 1�Q�需要进行类型�{换�?/p> 上面介绍了泛型�{化中的擦除技术，接下来，我们讨论一下泛型�{化中的另外一个重要问题－�Q�桥�Ҏ��Q�bridge method�Q��?/p> Java 是一�U�面向对象的语言�Q�因此覆盖（overridden�Q�是其中的一��w��要技术。覆盖能够正�?工作"的前提是�Ҏ��名和�Ҏ��的参数类型及个数完全匚w��Q�参数的��序也应一��_��Q��ؓ了满��要求，�~�译器在泛型转化中引入了桥方法（bridge method�Q�。接下来�Q�我们通过一个例子来分析一下桥�Ҏ��在泛型�{化中所��L��作用。在本文"泛化�Ҏ��和受限类型参�?一��节所�l�出的代码中�Q�第 9 行到�W?11 行的�E�序如下所�C�： 9 public int compareTo(Byte that) { 10 return this.value - that.value; 11 } �q�部分代码经�q��{化，��变成了下面的样子： 9 public int compareTo(Byte that) { 10 return this.value - that.value; 11 } 12 public int compareTo(Object that){ 13 return this.compareTo((Byte)that); 14 } �W?12 行的�Ҏ�� compareTo(Object that) ��是一个桥�Ҏ��Q�在�q�里引入�q�个�Ҏ��是�ؓ了保证覆盖能够正常的发生。我们在前面提到�q�，覆盖必须保证�Ҏ��名和参数的类型及数目完全匚w��Q�在�q�里通过引入�q�个"�?卛_��辑ֈ��q�一目的�Q�由�q�个"�?�q�行�c�d��转换�Q��ƈ调用�W?9 行参数类型�ؓ Byte 的方�?compareTo(Byte that)�Q�需要注意的一�Ҏ��q�里�?"Object" 也�ƈ不一定是完全匚w��的类型，但由于它�?Java 语言中类层次�l�构的根�Q�所以这里用 "Object" 可以接受其他��M��c�d��的参数�?/p> �Ҏ��面向对象的基本概念，我们知道�Q�重载（overloading�Q�允许桥�Ҏ��和原来的�Ҏ��׃�n同一个方法名�Q�正如上面例子所昄��的那��P��因此桥方法的引入是完全合法的。一般情况下�Q�当一个类实现了一个参数化的接口或是��承了一个参数化的类�Ӟ��需要引入桥�Ҏ��?/p> 到此�Q�我们对泛型中的子类型，带有泛型的类�Q�泛化方法，受限�c�d��参数以及泛型的�{化进行了��要的介绍�Q�下面部分将�l�合�q�些技术对前面提到的例子进行一下�ȝ��Q�以便能够帮助读者更深刻更全面地理解泛型�?/p> 首先来分析一下本文提到的那个 Collection 的例子。这里先是定义了两个接口 Collection �?Iterator�Q�然后又定义了一个对接口 Collection 的一个实�?LinkedList。根据上面所介绍的对泛型的�{化过�E�，�q�段代码转化后的 Java �E�序为： 1 interface Collection { 2 public void add (Object x); 3 public Iterator iterator (); 4 } 5 6 interface Iterator { 7 public Object next (); 8 public boolean hasNext (); 9 } 10 11 class NoSuchElementException extends RuntimeException {} 12 13 class LinkedList implements Collection { 14 15 protected class Node { 16 Object elt; 17 Node next = null; 18 Node (Object elt) { this.elt = elt; } 19 } 20 21 protected Node head = null, tail = null; 22 23 public LinkedList () {} 24 25 public void add (Object elt) { 26 if (head == null) { 27 head = new Node(elt); tail = head; 28 } else { 29 tail.next = new Node(elt); tail = tail.next; 30 } 31 } 32 33 public Iterator iterator () { 34 return new Iterator () { 35 protected Node ptr = head; 36 public boolean hasNext () { return ptr != null; } 37 public Object next () { 38 if (ptr != null) { 39 Object elt = ptr.elt; ptr = ptr.next; return elt; 40 } else { 41 throw new NoSuchElementException (); 42 } 43 } 44 }; 45 } 46 } 通过分析上述代码�Q�我们不隑֏�玎ͼ�所有参数化�c�d�� Collection, Iterator �?LinkedList 中的�c�d��参数 "A" 全都被擦除了。另外，剩下的类型变�?"A" 都用其上限进行了替换�Q�这里的上限�?Object�Q�见黑体字标出的部分�Q�这是�{化的关键部分�?/p> 下面我们分析一下在介绍有关泛化�Ҏ��Q�generic method�Q�和受限�c�d��参数�Q�bounded type parameter�Q�时丄��那个例子�Q�该�D?GJ 代码�l�过转换后的�{��h Java �E�序如下所�C�： 1 interface Comparable { 2 public int compareTo(Object that); 3 } 4 5 class Byte implements Comparable { 6 private byte value; 7 public Byte(byte value) {this.value = value;} 8 public byte byteValue(){return value;} 9 public int compareTo(Byte that) { 10 return this.value - that.value; 11 } 12 public int compareTo(Object that){ 13 return this.compareTo((Byte)that); 14 } 15 } 16 17 class Collections { 18 public static Comparable max(Collection xs){ 19 Iterator xi = xs.iterator(); 20 Comparable w = (Comparable)xi.next(); 21 while (xi.hasNext()) { 22 Comparable x = (Comparable)xi.next(); 23 if (w.compareTo(x) < 0) w = x; 23 } 24 return w; 25 } 26 } 同样误��者注意黑体字标出的部分，�q�些关键�Ҏ��们在前面已经介绍�q�了�Q�故不赘�q�。唯一需要注意的一点就是第 18�Q?0�Q?2 行出现的Comparable。在泛型转化中，�c�d��变量应该用其上限来替换，一般情况下�q�些上限�?"Object"�Q�但是当遇到受限的类型参数时�Q�这个上限就不再�?"Object" 了，�~�译器会用限制这些类型参数的�c�d��来替换它�Q�上�q�C��码就用了�?A �q�行限制的类�?"Comparable" 来替�?A�?/p> 桥方法的引入�Q��ؓ解决覆盖问题带来了方便，但是�q�种�Ҏ��q�存在一些问题，例如下面�q�段代码�Q?/p> 1 interface Iterator { 2 public boolean hasNext (); 3 public A next (); 4 } 5 class Interval implements Iterator { 6 private int i; 7 private int n; 8 public Interval (int l, int u) { i = l; n = u; } 9 public boolean hasNext () { return (i <= n); } 10 public Integer next () { return new Integer(i++); } 11 } �Ҏ��以上所讲的内容�Q�这部分代码转换后的 Java �E�序应该是如下这个样子： 1 interface Iterator { 2 3 public boolean hasNext (); 4 public Object next (); 5 6 } 7 8 class Interval implements Iterator { 9 10 private int i; 11 private int n; 12 public Interval (int l, int u) { i = l; n = u; } 13 public boolean hasNext () { return (i <= n); } 14 public Integer next%1% () { return new Integer(i++); } 15 // bridge 16 public Object next%2%() { return next%1%(); } 17 18 } �怿�有些读者已�l�发��C��q�里的问题，�q�不是一�D�合法的 Java 源程序，因�ؓ�W?14 行和�W?16 行的两个 next() 有相同的参数�Q�无法加以区分。代码中�?%1% �?%2% 是�ؓ了区分而�h为加入的�Q��ƈ�?GJ 转化的结果�?/p> 不过�Q�这�q�不是什么太大的问题�Q�因�?Java 虚拟机可以区分这两个 next() �Ҏ��Q�也��是��_��?Java 源程序的角度来看�Q�上�q�程序是不正��的�Q�但是当�~�译成字节码�Ӟ��JVM 可以对两�?next() �Ҏ��q�行识别。这是因为，�?JVM 中，�Ҏ��定义时所使用的方法签名包括方法的�q�回�c�d��Q�这样一来，只要 GJ �~�译出的字节码符合Java字节码的规范卛_��Q�这也正好说明了 GJ �?JVM 中字节码规范要求的一致性！最后，值得一提的是，JDK 5.0 除了在编译器层面�?Java 中的泛型�q�行了支持，Java 的类库�ؓ支持泛型也做了相应地调整�Q�例如，集合框架中所有的标准集合接口都进行了泛型化，同时�Q�集合接口的实现也都�q�行了相应地泛型化�?/p> 回页�?/strong>Java 中的泛型�?C++ 模板的比�?/span> GJ �E�序的语法在表面上与 C++ 中的模板非常�c�M��Q�但是二者之间有着本质的区别�?/p> 首先�Q�Java 语言中的泛型不能接受基本�c�d��作�ؓ�c�d��参数――它只能接受引用�c�d��。这意味着可以定义 List�Q�但是不可以定义 List�? 其次�Q�在 C++ 模板中，�~�译器��用提供的�c�d��参数来扩充模板，因此�Q��ؓ List 生成�?C++ 代码不同于�ؓ List 生成的代码，List �?List 实际上是两个不同的类。�?Java 中的泛型则以不同的方式实玎ͼ��~�译器仅仅对�q�些�c�d��参数�q�行擦除和替换。类�?ArrayList �?ArrayList 的对象共享相同的�c�，�q�且只存在一�?ArrayList �c�R�?/p> 回页�?/strong> �ȝ�� 本文通过一些示例从基本原理�Q�重要概念，关键技术，以及�怼�技术比较等多个角度�?Java 语言中的泛型技术进行了介绍�Q�希望这�U�介�l�方法能够帮助读者更好地理解和��用泛型。本文主要针对广大的 Java 语言使用者，在介�l�了泛型的基本概念后�Q�重点介�l�了比较底层的泛型�{化技术，旨在帮助读者更加深��d��掌握泛型�Q�笔者相信这部分内容可以使读者避免对泛型理解的表面化�Q�也所谓知其然更知其所以然�?/p> 参考资�? 诊断 Java 代码: ��L��掌握 Java 泛型�Q�developerWorks�Q?003 �q?5 月）�Q�在本文当中�Q�Eric Allen 通过描述诸如基本�c�d��限制和多态方法等�Ҏ��来说明泛型的优�~�点�?br /> Java 理论和实�? 了解泛型�Q�developerWorks�Q?005 �q?1 月）�Q�在本文当中�Q�Brian Goetz 通过�C�Z��分析了刚刚接触泛型的新用户常犯的错误�Q�从反面�l�用户以警示�?br /> 介绍 JDK 5.0 中的泛型�Q�developerWorks�Q?004 �q?12 月）�Q�一��关�?JDK 5.0 中的泛型的教�E�，该教�E�解释了�?Java 语言中引入泛型的动机�Q�详�l�介�l�了泛型的语法和语义�Q��ƈ讲述了如何在自己的类中��用泛型�?br /> 驯服 Tiger�p�d��专栏�Q�详�l�地讨论有关 Java SE 5 �q�_��的改变，�q�提供一些例子作为快速参考�?br /> Java 理论与实�?/em>�p�d��专栏�Q�探索设计模式，可靠软�g设计原则�Q�以及应用于实际问题�?#8220;最佛_��?#8221;�? GJ: Extending the Java programming language with type parameters�Q�Gilad Bracha, Martin Odersky �{��h写的一��介�l?GJ 基本概念的文章�?br /> Generics in the Java Programming Language�Q�Gilad Bracha 写的一��详�l�介�l?JDK 5.0 中的泛型的文章�?/li> 关于作�?/span> 周晶�Q?006�q?月毕业于北京航空航天大学计算机学院，莯��机��士学位。主要研�I��域�ؓ高��~�译技术，Java虚拟机技术�?beyond.zhou@gmail.com ammay 2009-12-14 22:52 发表评论
泛型 ammay — Mon, 14 Dec 2009 14:51:00 GMT Jdk1.5中的新特�?--泛型 (详细�? 本来只�{载了个链接，和一个简单的使用�E�序�Q�但昨天不小心看到有人批判jdk1.5�Q�先说java要强制�{型不好的问题没解冻I�� 容器不能攑֟��c�d��不好�Q�接着说泛型没用。而恰恰Jdk1.5中解决了�q�些问题�Q�所以感叹之余，把这��文章改一下，详细的说说泛型�?/p> 一�Q�Java中的泛型�Q?br /> 在Java中能使用到泛型的多是容器�c?如各�U�list map set�Q�因为Java是单根��承，所以容器里边可以放�?br /> 内容是�Q何Object�Q�所以从意义上讲原本的设计才是泛型。但用过Java的�h是否感觉每次转型很麻烦呢�Q?br /> 而且会有些错误，比如一个容器内攑օ�了异质对象，强制转型的时候会出现cast异常。而这中错误在�~�译器是无从发现的。所以jdk1.5中提供了泛型�Q�这个泛型其实是向c++靠拢�?好，我们先看几个实例再细说原理�?/p> 二，泛型的用�?(多个实例) 1 实例A 2 ArrayList < String > strList = new ArrayList < String > (); 3 strList.add( " 1 " ); 4 strList.add( " 2 " ); 5 strList.add( " 3 " ); 6 // 关键点（1�Q?nbsp;注意下边�q�行�Q�没有强制�{�?/span> 7 String str = strList.get( 1 ); 8 // 关键点（2�Q�然後我们加入，�q�个时候你会发现编译器报错�Q�错误在�~�译器被发现�Q�错误当然是发现的越早越�?/span> 9 strList.add( new Object()); 1 实例B 2 ArrayList < Integer > iList = new ArrayList < Integer > (); 3 // 关键点（3�Q?nbsp;注意直接把整数放入了集合中，而没有用Integer包裹 4 iList.add( 1 ); 5 iList.add( 2 ); 6 iList.add( 3 ); 7 // 关键点（4�Q�同��L��接取出就是int 8 int num = iList.get( 1 ); 1 实例C 2 // 关键点（5�Q�展�C�Z��下key-value的时候要怎么写，同时key和value也可以是基本�c�d��了�?/span> 3 HashMap < Integer,Integer > map = new HashMap < Integer,Integer > (); 4 map.put( 1 , 11 ); 5 map.put( 2 , 22 ); 6 map.put( 3 , 33 ); 7 int inum = map.get( 1 ); 8 三，看完了实例了�Q�详�l�来说说��Z��么吧首先jdk1.5中的泛型�Q�第一个解决的问题�Q�就是Java中很多不必要的强制�{型了�Q�具体的实现,我们以ArrayList ��Z��,下边是ArrayList中的片断代码: 1ArrayList�cȝ��定义�Q�这里加入了<E> 2public class ArrayList<E> extends AbstractList<E> 3        implements List<E>, RandomAccess, Cloneable, java.io.Serializable 4 5//get�Ҏ��,�q�回不再是Object 而是E 6public E get(int index) { 7    RangeCheck(index); 8    return elementData[index]; 9} 10//add�Ҏ��,参数不再是Object 而是E 11public boolean add(E o) { 12    ensureCapacity(size + 1);  // Increments modCount!! 13    elementData[size++] = o; 14    return true; 15} 16 四，Boxing 和UnBoxing 看到上边的关键点�Q?�Q�和�Q?�Q�是否感觉惊奇呢�Q�因为Java中烦人的除了强制转型�Q�另一个就是基��c�d��?br /> 攑օ�容器的时候要包装�Q�取��Z��q�要转回。Jdk1.5中解决了�q�个问题.如上边的使用�Ҏ�� 五，泛型的生命周期（使用注意事项�Q?br /> 如果我们试着把ArrayList list的内容序列化�Q�然後再��d��出来�Q�在使用的过�E�中会发现出错， ��Z��么呢�Q�用Stream��d��一下回来的数据�Q�你会发�?lt;String>不见了，list变成了普通的ArrayList�Q�而不�?br /> 参数化型别的ArrayList了，��Z��么会�q�样�?�Q�见下边的比�?/p> 六，C++的泛型和Java的泛�?br /> 在泛型的实现上，C++和Java有着很大的不同， Java是擦拭法实现�?br /> C++是膨胀法实现的因�ؓJava原本实现��是泛型的，现在加入型别�Q�其实是"�H�化",所以采用擦拭法�Q�在实现上，其实是封装了原本�?br /> ArrayList,�q�样的话�Q�对于下边这些情况，Java的实现类只有一个�?br /> 1ArrayList<Integer>  .;   public class ArrayList 2ArrayList<String>  ..;   --同上-- 3ArrayList<Double>  ..;   --同上-- 4而C++采用的是膨胀�?对于上边的三�U�情况实际是每一�U�型别都对应一个实玎ͼ�实现�c�L��多个 5list<int> li;                class list; //int 版本 6list<string> ls;             class list; //string 版本 7list<double> ld;             class list; //double 版本     �q�就造成了，在序列化后，Java不能分清楚原来的ArrayList�?br /> ArrayList�q�是ArrayList 七，题外话，在很多东西的实现上C++和Java有很多不�?br /> 例如�q�算�W�的问题i=i++问题�Q?a href="http://www.aygfsteel.com/dreamstone/archive/2006/11/04/79058.html">详细看这�?/a> 例如在C++中能很好实现的double-checked locking单态模式，在Java中几乎很隑֮��?详细看这�?/a> �q�有��是上边提到的泛型实��C��?br /> 八，Jdk 1.5加入了不��新东西�Q�有些能很大的提高开发质量，例如Jdk1.4 �Q�Jdk.15中StringBuffer的不�?br /> 因�ؓ�?�?转入1�?不久�Q�所以慢慢会发一些在1�?的��用过�E�中发现的东�ѝ�?br /> 最后，我们�q�可以自己写�c�M��ArrayList�q�样的泛型类�Q�至于如何自定义泛型�c�，泛型�Ҏ��请参见候捷先生的文�?br /> ammay 2009-12-14 22:51 发表评论 xquery ammay — Thu, 03 Dec 2009 14:43:00 GMT http://download.csdn.net/sort/tag/XQuery ammay 2009-12-03 22:43 发表评论 mysql triger ammay — Thu, 26 Nov 2009 14:56:00 GMT /Files/ammayjxf/MySQL.pdf ammay 2009-11-26 22:56 发表评论 ammay — Thu, 26 Nov 2009 14:31:00 GMT 我们在MySQL 5.0中包含对触发器的支持是由于以下原�? MySQL早期版本的用户长期有需要触发器的要求�?br /> 我们曄��许诺支持所有ANSI标准的特性�?br /> 您可以��用它来检查或预防坏的数据�q�入数据库�?br /> 您可以改变或者取消INSERT, UPDATE以及DELETE语句�?br /> 您可以在一个会话中监视数据改变的动作。在�q�里我假定大安��读过"MySQL新特�?丛书的第一�?-"MySQL存储�q�程"�Q�那么大安��应该知道MySQL��x��存储�q�程和函敎ͼ�那是很重要的知识�Q�因为在触发器中你可以��用在函数中��用的语句。特别�D个例子：复合语句(BEGIN / END)是合法的. ��控�Ӟ��Flow-of-control�Q�语�?IF, CASE, WHILE, LOOP, WHILE, REPEAT, LEAVE,ITERATE)也是合法�? 变量声明(DECLARE)以及指派(SET)是合法的. 允许条�g声明. 异常处理声明也是允许�? 但是在这里要��C��函数有受限条�?不能在函��C��讉K��? 因此在函��C��使用以下语句是非法的�?br /> ALTER 'CACHE INDEX' CALL COMMIT CREATE DELETE DROP 'FLUSH PRIVILEGES' GRANT INSERT KILL LOCK OPTIMIZE REPAIR REPLACE REVOKE ROLLBACK SAVEPOINT 'SELECT FROM table' 'SET system variable' 'SET TRANSACTION' SHOW 'START TRANSACTION' TRUNCATE UPDATE 在触发器中也有完全一��L��限制.触发器相对而言比较斎ͼ�因此会有�Q�bugs�Q�缺�?所以我在这里给大家警告�Q�就像我在存储过�E�书中所说那�?不要在含有重要数据的数据库中使用�q�个触发器，如果需要的话在一些以��试为目的的数据库上使用�Q�同时在你对表创��发器时确认这些数据库是默认的�?/p> 语法 1. 语法�Q�命名规�?/p> CREATE TRIGGER <触发器名�U?gt; <-- { BEFORE | AFTER } { INSERT | UPDATE | DELETE } ON <表名�U?gt; FOR EACH ROW <触发器SQL语句> 触发器必��L��名字�Q�最�?4个字�W�，可能后面会附有分隔符.它和MySQL中其他对象的命名方式基本相象. �q�里我有个习惯：��是用表的名字＋'_'�Q�触发器�c�d��的羃�?因此如果是表t26�Q�触发器是在事�gUPDATE�Q�参考下面的点（2�Q�和�Q?�Q�）之前�Q�BEFORE�Q�的�Q�那么它的名字就是t26_bu�? 2. 语法�Q�触发时�?/p> CREATE TRIGGER <触发器名�U?gt; { BEFORE | AFTER } <-- { INSERT | UPDATE | DELETE } ON <表名�U?gt; FOR EACH ROW <触发的SQL语句> 触发器有执行的时间设�|�：可以讄��Z��件发生前或后�?/p> 3. 语法�Q�事�?/p> CREATE TRIGGER <触发器名�U?gt; { BEFORE | AFTER } { INSERT | UPDATE | DELETE } <-- ON <表名�U?gt; FOR EACH ROW <触发的SQL语句> 同样也能讑֮�触发的事�Ӟ��它们可以在执行insert、update或delete的过�E�中触发�?br /> 4. 语法�Q�表 CREATE TRIGGER <触发器名�U?gt; { BEFORE | AFTER } { INSERT | UPDATE | DELETE } ON <表名�U?gt; <-- FOR EACH ROW <触发的SQL语句> 触发器是属于某一个表�?当在�q�个表上执行插入�?br /> 更新或删除操作的时候就��D��触发器的�Ȁ�z? 我们不能�l�同一张表的同一个事件安排两个触发器�?/p> 5. 语法�Q�（步长�Q�触发间�?/p> CREATE TRIGGER <触发器名�U?gt; { BEFORE | AFTER } { INSERT | UPDATE | DELETE } ON <表名�U?gt; FOR EACH ROW <-- <触发的SQL语句> 触发器的执行间隔�Q�FOR EACH ROW子句通知触发�?br /> 每隔一行执行一�ơ动作，而不是对整个表执行一�ơ�?/p> 6. 语法�Q�语�?/p> CREATE TRIGGER <触发器名�U?gt; { BEFORE | AFTER } { INSERT | UPDATE | DELETE } ON <表名�U?gt; FOR EACH ROW <触发的SQL语句> <-- 触发器包含所要触发的SQL语句�Q�这里的语句可以是�Q何合法的语句�Q?br /> 包括复合语句�Q�但是这里的语句受的限制和函数的一栗��?br /> Privileges权限你必��L��有相当大的权限才能创��发器�Q�CREATE TRIGGER�Q��?br /> 如果你已�l�是Root用户�Q�那么就��_��了。这跟SQL的标准有所不同�?/p> 因此在下一个版本的MySQL中，你完全有可能看到有一�U�叫做CREATE TRIGGER的新权限�?br /> 然后通过�q�样的方法赋予： GRANT CREATE TRIGGER ON <表名�U?gt; TO <用户或用户列�?gt;; 也可以通过�q�样收回权限�Q?br /> REVOKE CREATE TRIGGER ON <表名�U?gt; FROM <用户或用户列�?gt;; 关于旧的和新创徏的列的标�?/p> 在触发器的SQL语句中，你可以关联表中的��L��列。但你不能仅使用列的名称��L��识，那会使系�l��؜淆，因�ؓ那里可能会有列的新名�Q�这可能正是你要修改的，你的动作可能正是要修改列名）�Q�还有列的旧名存在。因此你必须用这��L��语法来标识： "NEW . column_name"或�?OLD . column_name".�q�样在技术上处理�Q�NEW | OLD . column_name�Q�新和旧的列名属于创��Z��q�渡变量�Q?transition variables"�Q��? 对于INSERT语句,只有NEW是合法的�Q�对于DELETE语句�Q�只有OLD才合法；而UPDATE语句可以在和NEW以及OLD同时使用。下面是一个UPDATE中同时��用NEW和OLD的例子�? CREATE TRIGGER t21_au BEFORE UPDATE ON t22 FOR EACH ROW BEGIN SET @old = OLD . s1; SET @new = NEW.s1; END;// 现在如果t21表中的s1列的值是55�Q�那么执行了 "UPDATE t21 SET s1 = s1 + 1"之后@old的��g��变成55�Q?br /> 而@new的值将会变�?6。Example of CREATE and INSERT CREATE和INSERT的例�?br /> 创徏有触发器的表 �q�里所有的例程中我都假定大家的分隔�W�已�l�设�|�成//�Q�DELIMITER //�Q��?br /> CREATE TABLE t22 (s1 INTEGER)// CREATE TRIGGER t22_bi BEFORE INSERT ON t22 FOR EACH ROW BEGIN SET @x = 'Trigger was activated!'; SET NEW.s1 = 55; END;// 在最开始我创徏了一个名字�ؓt22的表�Q�然后在表t22上创��Z��一个触发器t22_bi�Q�当我们要向表中的行插入�Ӟ��触发器就会被�Ȁ�z�，执行��s1列的值改�?5的动作�?/p> 使用触发器执行插入动�? mysql> INSERT INTO t22 VALUES (1)// 让我们看如果向表t2中插入一行数据触发器对应的表会怎么��P�� q�里的插入的动作是很常见的，我们不需要触发器的权限来执行它。甚至不需要知道是否有触发器关联�? mysql> SELECT @x, t22.* FROM t22// +------------------------+------+ | @x | s1 | +------------------------+------+ | Trigger was activated! | 55 | +------------------------+------+ 1 row in set (0.00 sec) 大家可以看到INSERT动作之后的结果，和我们预期的一��P��x标记被改动了�Q�同时这里插入的数据不是我们开始输入的插入数据�Q�而是触发器自��q��数据�? "check"完整性约束例�?br /> 什么是"check"�U�束在标准的SQL语言中，我们可以在（CREATE TABLE�Q�创��的过�E�中使用"CHECK (condition)"�Q?br /> 例如�Q?br /> CREATE TABLE t25 (s1 INT, s2 CHAR(5), PRIMARY KEY (s1), CHECK (LEFT(s2,1)='A')) ENGINE=INNODB; �q�里CHECK的意思是"当s2列的最左边的字�W�不�?A'�Ӟ��insert和update语句都会非法"�Q�MySQL的视图不支持CHECK�Q�我个�h是很希望它能支持的。但如果你很需要在表中使用�q�样的功能，我徏议大家��用触发器来实现�? CREATE TABLE t25 (s1 INT, s2 CHAR(5), PRIMARY KEY (s1)) ENGINE=INNODB// CREATE TRIGGER t25_bi BEFORE INSERT ON t25 FOR EACH ROW IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;// CREATE TRIGGER t25_bu BEFORE UPDATE ON t25 FOR EACH ROW IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;// 我只需要��用BEFORE INSERT和BEFORE UPDATE语句��p��了，删除了触发器不会对表有媄响，同时AFTER的触发器也不能修改NEW的过�E�变量（transition variables�Q�。�ؓ了激�z�触发器�Q�我执行了向表中的行插入s1�Q?的数据，之后只要执行�W�合LEFT(s2,1) <> 'A'条�g的动作都会失败： INSERT INTO t25 VALUES (0,'a') /* priming the pump */ // INSERT INTO t25 VALUES (5,'b') /* gets error '23000' */ // Don't Believe The Old MySQL Manual 本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/crazy_rain/archive/2007/07/05/1680128.aspx ammay 2009-11-26 22:31 发表评论 ant工程配置 ammay — Thu, 19 Nov 2009 13:16:00 GMT 2008-09-25 ANT工程配置 �l�于把ANT搞定了，现在发布一个通用的ANT的build.xml文�g�Q�以备后用�? Java代码 "hnwt114" default="build" basedir=".">                "hnwt144.home" value="."/>                "hnwt144.name" value="HNWT114"/>                "tomcat.home" value="D:\apache-tomcat-5.5.26"/>                "webapps.home" value="${tomcat.home}/webapps"/>                "src.home" value="${hnwt144.home}/src"/>                        "classes.home" value="${hnwt144.home}/classes"/>                "deploy.home" value="${hnwt144.home}/deploy"/>                "web.home" value="${hnwt144.home}/webRoot"/>                        "build.home" value="${hnwt144.home}/build"/>                "build.classes" value="${hnwt144.home}/WEB-INF/classes"/>                "build.lib" value="${hnwt144.home}/WEB-INF/lib"/>                "lib.home" value="${web.home}/WEB-INF/lib"/>                                "compile.classpath">            "${classes.home}"/>            "${lib.home}">                    "*.jar"/>                    "*.zip"/>                        "${tomcat.home}/common/lib">                "*.jar"/>                        "${tomcat.home}/common/classes"/>                                        "help">            "Please specify a target![usage:ant<targetname>]"/>            "Here is a list of possible targets:"/>            "  clean-all....Delete build dir,all .class and war files"/>            "  perpare....Creates directories if requied"/>            "  compile....Compiles source files"/>            "  build......Build war file from.class and other files"/>            "  deploy......Copy war file to the webapps directory"/>                                        "clean-all">            "${build.home}"/>            "${classes.home}"/>            "${deploy.home}"/>                        "${webapps.home}/${hnwt114.home}" failonerror="false"/>            "${webapps.home}/${hnwt114.name}.war"/>                                        "prepare">            "Tomcat Home=${tomcat.home}"/>            "Webapps Home=${webapps.home}"/>                        "${classes.home}"/>            "${deploy.home}"/>                             "${build.home}"/>            "${build.home}/WEB-INF"/>            "${build.home}/WEB-INF/classes"/>            "${build.home}/WEB-INF/lib"/>                                        "compile" depends="prepare">            "${src.home}" destdir="${classes.home}" debug="no">                "compile.classpath"/>                                            "build" depends="compile">            "${build.home}">                "${web.home}"/>                        "${build.home}/WEB-INF/classes">                "${classes.home}"/>                                    "${build.home}/WEB-INF/classes">                "${src.home}">                    "**/*.properties"/>                    "**/*.prop"/>                                                    "${deploy.home}/${hnwt144.name}.war" basedir="${build.home}"/>                        "deploy" depends="build">            "${webapps.home}" file="${deploy.home}/${hnwt144.name}.war"/>                               ammay 2009-11-19 21:16 发表评论 ammay — Thu, 19 Nov 2009 13:09:00 GMT 2009-04-10 ant 的��用说�?/a> 关键�? ant 的��用说�?/strong> >>>>>>>>>>>声明 1.目的是学习，备忘�Q�共享。个��达能力有限，看不懂，表达错误的，见谅 >>>>>>>>>>>ant是什�? 1.专业一点说是构建工��P��是协助开发�h员管理工�E�的工具 2.通俗一点说是懒人工��P��帮助我们做一些重复的力_�� 3.举个例子�Q�发布一个web工程�Q�你会如何做 a.��web工程打包 b.停止web工程 c.上传web工程 d.重启web工程　通常�Q�你可能会用IDE打包�Q�然后登陆到服务器，把WEB工程shutdown�Q�再用上传工具传war包，然后再重�? 　有了ant�Q�你不用�q�么累了�Q�运行一个build.xml��OK�? >>>>>>>>>>ant的特�? 1.跨��^収ͼ�因�ؓ用JAVA写的 2.功能强大(�q�是一个口�?�Q�扩展性比较好(�q�倒是实话�Q�但代�h是你得找支持的jar�? 3.上手�Ҏ��Q�因��法简�? >>>>>>>>>>ant的应�?eclipse�? 1.传说牛�h都不用IDE�Q�我用eclipse�Q�这玩意儿还是免费的�Q�真��? 2.exlipse3.0以后应该都内嵌ant�Q�找扄��Q?eclipse\plugins\org.apache.ant_1.6.5 3.新徏工程�Q�工�E�根目录下新建build.xml 4.试试好不用，�q�行一�? Java代码 "1.0" encoding="UTF-8"?>    "WebTest" basedir="E:\work_ccats2\WebTest" default="main">    "main" depends="test" description="Main target">       "test" description="test">         task start          task start 5.ftp功能�Q? a.下蝲commons-net-1.4.0.jar jakarta-oro-2.0.8.jar NetComponents.jar optional.jar b.上面�q�些jar�Q�如果你的ant或jdk版本高，有的没有�Q�但如果不是�Q�劝你都�? c.eclipse�? Window->Preferance->Ant->Runtime->Ant Home Entries->自己加上jar 6.ssh: a.下蝲jsch-0.1.41.jar b.后面同[5] 7.�l�一个build.xml样例 Java代码 "1.0" encoding="UTF-8"?>    "WebTest" basedir="E:\work_ccats2\WebTest" default="main">        "main" depends="taskover" description="Main target">                                        "project.name" value="WebTest"/>                "hostIP" value="10.4.116.212" />                "userID" value="esb" />                "password" value="esb" />                "hostHome" value="/home/esb" />                                "test" description="test">             task start                        "pgWar" depends="test" description="Package application as a war">            "${war.dir}" />            "${war.dir}/${project.name}.war" webxml="web.xml">                "${basedir}">                                                            "remote-tomcat-stop" depends="pgWar" >                "${hostIP}" username="${userID}"  password="${password}"                    command="ps -ef|grep tomcat55|grep -v grep |awk '{print $2}'|xargs -n1 kill -9;ls;rm -rf /home/esb/tomcat55/webapps/WebTest*"                    trust="true" />                "5"/>                                "uploadFile" depends="remote-tomcat-stop" >            "${hostIP}" remotedir="${hostHome}/tomcat55/webapps" userid="${userID}"                password="${password}" depends="yes" >                "${war.dir}">                    "**/*.war"/>                                                                "remote-tomcat-start" depends="uploadFile" >                "${hostIP}" username="${userID}"  password="${password}"                    command="cd /home/esb/tomcat55/bin;JAVA_HOME=/home/esb/jdk1.5/jdk1.5.0_06 export JAVA_HOME;nohup sh startup.sh;ls"                    trust="true" />                "5"/>                                    "taskover" depends="remote-tomcat-start" >                 task over                           task start task over >>>>>>>>>>>>>命��o行下的ant应用 1.环境变量设一�? ANT_HOME= $ant路径 PATH = %ANT_HOME%;%ANT_HOME%\bin 2.��试输入ant�Q�看有反应没 ammay 2009-11-19 21:09 发表评论


		周晶�Q?006�q?月毕业于北京航空航天大学计算机学院，莯��机��士学位。主要研�I��域�ؓ高��~�译技术，Java虚拟机技术�?beyond.zhou@gmail.com