[转]Java1.5泛型指南中文版(Java1.5 Generic Tutorial)

Java1.5 泛型指南中文版 (Java1.5 Generic Tutorial)： http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx

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

                                                  译者：  [e-mail]

 

目          录

 

摘要和关键字

1.         介绍

2.         定义简单的泛型

3.         泛型和子类继承

4.         通配符 ( Wildcards )

4.1.         有限制的通配符 (Bounded Wildcards)

5.         泛型方法

6.         与旧代码交互

6.1.         在泛型代码中使用老代码

6.2.         擦除和翻译 (Erasure and Translation)

6.3.     在老代码中使用泛型代码

7.         要点 (The Fine Print)

7.1.         一个泛型类被其所有调用共享

7.2.         转型和 instanceof

7.3.         数组 Arrays

8.         Class Literals as Run-time Type Tokens

9.         More fun with *

9.1.         通配符匹配 (wildcard capture)

10.       泛型化老代码

11.       致谢

 

摘要和关键字

        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

     

 

1.             介绍

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

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

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

下面是那种典型用法：

       List myIntList =  new   LinkedList(); // 1

          myIntList.add( new  Integer(0)); // 2

       Integer x = (Integer) myIntList.iterator().next(); // 3

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

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

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

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

        myIntList.add( new  Integer(0));  // 2

       Integer x = myIntList.iterator().next();  // 3

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

另一个需要注意的是第 3 行没了类型转换。

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

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

2.             定义简单的泛型

下面是从 java.util 包中的 List 接口和 Iterator 接口的定义中摘录的片断：

public   interface  List<E> {

             void  add(E x);

            Iterator<E> iterator();

}

public   interface  Iterator<E> {

            E next();

             boolean  hasNext();

}

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

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

（原文： 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) ）

 

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

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

public   interface   IntegerList {

void   add(Integer x)

Iterator<Integer> iterator();

}

这种直觉可能有帮助，但是也可能导致误解。

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

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

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

分享到：

UDP打洞，穿透NAT | Ant中的classpath配置和使用

• 2010-07-07 23:28
• 浏览 707
• 评论(0)
• 查看更多