转贴 java 泛型，辛苦译者了

最新推荐文章于 2021-02-17 01:31:09 发布

anxin587

最新推荐文章于 2021-02-17 01:31:09 发布

阅读量91

点赞数

分类专栏： JAVA 文章标签： Java 交通 J2SE 数据结构 SUN

JAVA 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java1.5泛型指南中文版(Java1.5 Generic Tutorial)<o:p></o:p>

英文版pdf下载链接：http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

译者： chengchengji@163.com

<o:p> </o:p>

目录<o:p></o:p>

<o:p> </o:p>

摘要和关键字... 1<o:p></o:p>

1. 介绍... 1<o:p></o:p>

2. 定义简单的泛型... 2<o:p></o:p>

3. 泛型和子类继承... 3<o:p></o:p>

4. 通配符(Wildcards). 4<o:p></o:p>

4.1. 有限制的通配符(Bounded Wildcards). 5<o:p></o:p>

5. 泛型方法... 6<o:p></o:p>

6. 与旧代码交互... 9<o:p></o:p>

6.1. 在泛型代码中使用老代码... 9<o:p></o:p>

6.2. 擦除和翻译(Erasure and Translation). 10<o:p></o:p>

6.3. 在老代码中使用泛型代码... 11<o:p></o:p>

7. 要点(The Fine Print). 12<o:p></o:p>

7.1. 一个泛型类被其所有调用共享... 12<o:p></o:p>

7.2. 转型和instanceof 13<o:p></o:p>

7.3. 数组Arrays. 13<o:p></o:p>

8. Class Literals as Run-time Type Tokens. 14<o:p></o:p>

9. More fun with *. 16<o:p></o:p>

9.1. 通配符匹配(wildcard capture). 18<o:p></o:p>

10. 泛型化老代码... 18<o:p></o:p>

11. 致谢... 20<o:p></o:p>

<o:p> </o:p>

摘要和关键字<o:p></o:p>

generics、type safe、type parameter(variable)、formal type parameter、actual type parameter、wildcards(?)、unknown type、? extends T、? super T、erasure、translation、cast、instanceof、arrays、Class Literals as Run-time Type Tokens、wildcard capture、multiple bounds(T extends T1& T2 ... & Tn)、covariant returns<o:p></o:p>

<o:p></o:p>

<o:p> </o:p>

1. 介绍<o:p></o:p>

JDK1.5中引入了对java语言的多种扩展，泛型(generics)即其中之一。<o:p></o:p>

这个教程的目标是向您介绍java的泛型(generic)。你可能熟悉其他语言的泛型，最著名的是C++的模板(templates)。如果这样，你很快就会看到两者的相似之处和重要差异。如果你不熟悉相似的语法结构，那么更好，你可以从头开始而不需要忘记误解。<o:p></o:p>

Generics允许对类型进行抽象(abstract over types)。最常见的例子是集合类型(Container types)，Collection的类树中任意一个即是。<o:p></o:p>

下面是那种典型用法：<o:p></o:p>

List myIntList = new LinkedList();// 1<o:p></o:p>

myIntList.add(new Integer(0));// 2<o:p></o:p>

Integer x = (Integer) myIntList.iterator().next();// 3<o:p></o:p>

第3行的类型转换有些烦人。通常情况下，程序员知道一个特定的list里边放的是什么类型的数据。但是，这个类型转换是必须的(essential)。编译器只能保证iterator返回的是Object类型。为了保证对Integer类型变量赋值的类型安全，必须进行类型转换。<o:p></o:p>

当然，这个类型转换不仅仅带来了混乱，它还可能产生一个运行时错误(run time error)，因为程序员可能会犯错。<o:p></o:p>

程序员如何才能明确表示他们的意图，把一个list中的内容限制为一个特定的数据类型呢？这是generics背后的核心思想。这是上面程序片断的一个泛型版本:<o:p></o:p>

List<Integer> myIntList = new LinkedList<Integer>(); // 1<o:p></o:p>

myIntList.add(new Integer(0)); // 2<o:p></o:p>

Integer x = myIntList.iterator().next(); // 3<o:p></o:p>

注意变量myIntList的类型声明。它指定这不是一个任意的List，而是一个Integer的List，写作：List<Integer>。我们说List是一个带一个类型参数的泛型接口(a generic interface that takes a type parameter)，本例中，类型参数是Integer。我们在创建这个List对象的时候也指定了一个类型参数。<o:p></o:p>

另一个需要注意的是第3行没了类型转换。 <o:p></o:p>

现在，你可能认为我们已经成功地去掉了程序里的混乱。我们用第1行的类型参数取代了第3行的类型转换。然而，这里还有个很大的不同。编译器现在能够在编译时检查程序的正确性。当我们说myIntList被声明为List<Integer>类型，这告诉我们无论何时何地使用myIntList变量，编译器保证其中的元素的正确的类型。与之相反，一个类型转换说明程序员认为在那个代码点上它应该是那种类型。<o:p></o:p>

实际结果是，这可以增加可读性和稳定性(robustness)，尤其在大型的程序中。<o:p></o:p>

2. 定义简单的泛型<o:p></o:p>

下面是从java.util包中的List接口和Iterator接口的定义中摘录的片断：<o:p></o:p>

public interface List<E> {<o:p></o:p>

void add(E x);<o:p></o:p>

Iterator<E> iterator();<o:p></o:p>

}<o:p></o:p>

public interface Iterator<E> {<o:p></o:p>

E next();<o:p></o:p>

boolean hasNext();<o:p></o:p>

}<o:p></o:p>

这些都应该是很熟悉的，除了尖括号中的部分，那是接口List和Iterator中的形式类型参数的声明(the declarations of the formal type parameters of the interfaces List and Iterator)。<o:p></o:p>

类型参数在整个类的声明中可用，几乎是所有可是使用其他普通类型的地方(但是有些重要的限制，请参考第7部分)。<o:p></o:p>

（原文：Type parameters can be used throughout the generic declaration, pretty much where you would use ordinary types (though there are some important restrictions; see section 7)）<o:p></o:p>

<o:p> </o:p>

在介绍那一节我们看到了对泛型类型声明List(the generic type declaration List)的调用，如List<Integer>。在这个调用中(通常称作一个参数化类型a parameterized type)，所有出现形式类型参数(formal type parameter,这里是E)都被替换成实体类型参数(actual type argument)(这里是Integer)。<o:p></o:p>

你可能想象,List<Integer>代表一个E被全部替换成Integer的版本：<o:p></o:p>

public interface IntegerList {<o:p></o:p>

void add(Integer x)<o:p></o:p>

Iterator<Integer> iterator();<o:p></o:p>

}<o:p></o:p>

这种直觉可能有帮助，但是也可能导致误解。<o:p></o:p>

它有帮助，因为List<Integer>的声明确实有类似这种替换的方法。<o:p></o:p>

它可能导致误解，因为泛型声明绝不会实际的被这样替换。没有代码的多个拷贝，源码中没有、二进制代码中也没有；磁盘中没有，内存中也没有。如果你是一个C++程序员，你会理解这是和C++模板的很大的区别。<o:p></o:p>

一个泛型类型的声明只被编译一次，并且得到一个class文件，就像普通的class或者interface的声明一样。<o:p></o:p>

类型参数就跟在方法或构造函数中普通的参数一样。就像一个方法有形式参数(formal value parameters)来描述它操作的参数的种类一样，一个泛型声明也有形式类型参数(formal type parameters)。当一个方法被调用，实参(actual arguments)替换形参，方法体被执行。当一个泛型声明被调用，实际类型参数(actual type arguments)取代形式类型参数。<o:p></o:p>

一个命名的习惯：我们推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母，这使它和其他的普通的形式参数很容易被区分开来。许多容器类型使用E作为其中元素的类型，就像上面举的例子。在后面的例子中还会有一些其他的命名习惯。<o:p></o:p>

<o:p> </o:p>