j2se 5.0中的泛型

版权声明 ：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
英文原文地址:
http://www.onjava .com/pub/a/onjava /2005/07/06/generics.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43634_java _generics.html
关键词： java generics java 5

摘要
       泛型是j2se 5.0最重要的特性。他们让你写一个type(类或接口）和创建一个实例通过传递一个或多个引用类型。这个实例受限于只能作用于这些类型。比如，在java 5，java .util.list 已经被泛化。当建立一个list对象时，你通过传递一个java 类型建立一个list实例，此list实例只能作用于所传递的类型。这意味着如果你传递一个string ,此list实例只能拥有string对象；如果你传递一个integer，此实例只能存贮integer对象。除了创建参数化的类型，你还能创建参数化的函数。
     泛型的第一个好处是编译时的严格类型检查。这是集合框架 最重要的特点。此外,泛型消除了绝大多数的类型转换。在jdk 5.0之前，当你使用集合框架 时，你不得不进行类型转换。
     本文将教你如何操作泛型。它的第一部分是“没有泛型的日子”，先让我们回忆老版本jdk的不便。然后，举一些泛型的例子。在讨论完语法以及有界泛型的使用之后，文章最后一章将解释如何写泛型。
  

没有泛型的日子
     所有的java 类都源自java .lang.object,这意味着所有的java 对象能转换成object。因此，在之前的jdk的版本中，很多集合框架 的函数接受一个object参数。所以，collections是一个能持有任何对象的多用途工具，但带来了不良的后果。

     举个简单的例子，在jdk 5.0的之前版本中，类list的函数add接受一个object参数：

public boolean add(java

.lang.object element)

        所以你能传递任何类型给add。这是故意这么设计的。否则，它只能传递某种特定的对象，这样就会出现各种list类型，如，stringlist, employeelist, addresslist等。
     add通过object传递能带来好处,现在我们考虑get函数(返回list中的一个元素).如下是jdk 5之前版本的定义：

public java

.lang.object get(int index) throws indexoutofboundsexception

get返回一个object.不幸的事情从此开始了.假如你储存了两个string对象在一个list中:

list stringlist1 = new arraylist();
stringlist1.add("java

 5");
stringlist1.add("with generics");

当你想从stringlist1取得一个元素时,你得到了一个object.为了操作原来的类型元素,你不得不把它转换为string。

string s1 = (string) stringlist1.get(0);

但是,假如你曾经把一个非string对象加入stringlist1中,上面的代码会抛出一个classcastexception. 有了泛型,你能创建一个单一用途的list实例.比如,你能创建一个只接受string对象的list实例,另外一个实例只能接受employee对象.这同样适用于集合框架 中的其他类型.


泛型入门

   像一个函数能接受参数一样,一个泛型也能接受参数.这就是一个泛型经常被称为一个参数化类型的原因.但是不像函数用()传递参数,泛型是用<>传递参数的.声明一个泛型和声明一个普通类没有什么区别,只不过你把泛型的变量放在<>中.
     比如,在jdk 5中,你可以这样声明一个java .util.list :  list<e> mylist;
e 称为类型变量.意味着一个变量将被一个类型替代.替代类型变量的值将被当作参数或返回类型.对于list接口来说,当一个实例被创建以后,e 将被当作一个add或别的函数的参数.e 也会使get或别的参数的返回值.下面是add和get的定义:

boolean add<e o>
e get(int index)

note: 一个泛型在声明或例示时允许你传递特定的类型变量: e.除此之外,如果e是个类，你可以传递子类；如果e是个接口，你可以传递实现接口的类；

-----------------------------译者添加--------------------
list<number> numberlist= new arraylist<number>();
   numberlist.add(2.0);
   numberlist.add(2);
-----------------------------译者添加--------------------

如果你传递一个string给一个list，比如：

list<string> mylist;

那么mylist的add函数将接受一个string作为他的参数，而get函数将返回一个string.因为返回了一个特定的类型，所以不用类型转化了。

note ：根据惯例，我们使用一个唯一的大写字目表示一个类型变量。为了创建一个泛型，你需在声明时传递同样的参数列表。比如，你要想创建一个arraylist来操作string ，你必须把string放在<>中。如：

list<string> mylist = new arraylist<string>();

再比如，java .util.map 是这么定义的：

public interface map<k,v>

k用来声明map键(key)的类型而v用来表示值(value)的类型。put和values是这么定义的：

v put(k key, v value)
collection<v> values()

note :一个泛型不准直接的或间接的是java .lang.throwable的子类。因为异常是在运行时抛出的,所以它不可能预言什么类型的异常将在编译时抛出.

列表1的例子将比较list在jdk 1.4 和jdk1.5的不同

package com.brainysoftware.jdk5.app16;
import java

.util.list;
import java

.util.arraylist;

public class genericlisttest {
  public static void main(string[] args) {
    // in jdk 1.4
    list stringlist1 = new arraylist();
    stringlist1.add("java

 1.0 - 5.0");
    stringlist1.add("without generics");
    // cast to java

.lang.string
    string s1 = (string) stringlist1.get(0);
    system.out.println(s1.touppercase());

    // now with generics in jdk 5
    list<string> stringlist2 = new arraylist<string>();
    stringlist2.add(&quot;java

 5.0&quot;);
    stringlist2.add(&quot;with generics&quot;);
    // no need for type casting
    string s2 = stringlist2.get(0);
    system.out.println(s2.touppercase());
  }
}

在列表1中，stringlist2是个泛型。声明list<string>告诉编译器list的实例能接受一个string对象。当然，在另外的情况中，你能新建能接受各种对象的list实例。注意，当从list实例中返回成员元素时，不需要对象转化，因为他返回的了你想要的类型，也就是string.

note :泛型的类型检查(type checking)是在编译时完成的.

      最让人感兴趣的事情是，一个泛型是个类型并且能被当作一个类型变量。比如，你想你的list储存lists of strings,你能通过把list<string>作为他的类型变量来声明list。比如：

list<list<string>> mylistoflistsofstrings;

要从mylist中的第一个list重新取得string，你可以这么用：

string s = mylistoflistsofstrings.get(0).get(0);

下一个列表中的listofliststest类示范了一个list（命名为listoflists）接受一个string list作为参数。

package com.brainysoftware.jdk5.app16;
import java

.util.arraylist;
import java

.util.list;
public class listofliststest {
  public static void main(string[] args) {
    list<string> listofstrings = new arraylist<string>();
    listofstrings.add(&quot;hello again&quot;);
    list<list<string>> listoflists = new arraylist<list<string>>();
    listoflists.add(listofstrings);
    string s = listoflists.get(0).get(0);
    system.out.println(s); // prints &quot;hello again&quot;
  }
}

另外，一个泛型接受一个或多个类型变量。比如，java .util.map有两个类型变量s。第一个定义了键（key）的类型，第二个定义了值（value)的类型。下面的例子讲教我们如何使用个一个泛型map.

package com.brainysoftware.jdk5.app16;
import java

.util.hashmap;
import java

.util.map;
public class maptest {
  public static void main(string[] args) {
    map<string, string> map = new hashmap<string, string>();
    map.put(&quot;key1&quot;, &quot;value1&quot;);
    map.put(&quot;key2&quot;, &quot;value2&quot;);
    string value1 = map.get(&quot;key1&quot;);
  }
}

在这个例子中，重新得到一个key1代表的string值，我们不需要任何类型转换。

没有参数的情况下使用泛型

    既然在j2se 5.0中收集类型已经泛型化，那么，原来的使用这些类型的代码将如何呢？很幸运，他们在java 5中将继续工作，因为你能使用没有参数的泛型。比如，你能继续像原来一样使用list接口，正如下面的例子一样。

list stringlist1 = new arraylist();
stringlist1.add("java

 1.0 - 5.0");
stringlist1.add("without generics");
string s1 = (string) stringlist1.get(0);

一个没有任何参数的泛型被称为原型(raw type)。它意味着这些为jdk1.4或更早的版本而写的代码将继续在java 5中工作。

尽管如此，一个需要注意的事情是，jdk５编译器希望你使用带参数的泛型。否则，编译器将提示警告，因为他认为你可能忘了定义类型变量s。比如，编译上面的代码的时候你会看到下面这些警告，因为第一个list被认为是原型。

note: com/brainysoftware/jdk5/app16/genericlisttest.java
        uses unchecked or unsafe operations.
note: recompile with -xlint:unchecked for details.

当你使用原型时，如果你不想看到这些警告，你有几个选择来达到目的：
1.编译时带上参数-source 1.4
2.使用@supresswarnings(&quot;unchecked&quot;)注释
3.更新你的代码，使用list<object>. list<object>的实例能接受任何类型的对象，就像是一个原型list。然而，编译器不会报错。

使用 ？ 通配符
   前面提过，如果你声明了一个list<atype>, 那么这个list对atype起作用，所以你能储存下面这些类型的对象：
1.一个atype的实例
2.它的子类的实例(如果atype是个类)
3.实现atype接口的类实例(如果atype是个接口)
但是，请注意，一个泛型本身是个java 类型，就像java .lang.string或java .io.file一样。传递不同的类型变量给泛型可以创建不同的java 类型。比如，下面例子中list1和list2引用了不同的类型对象。

list<object> list1 = new arraylist<object>();
list<string> list2 = new arraylist<string>();

list1指向了一个类型变量s为java .lang.objects 的list而list2指向了一个类型变量s为string 的list。所以传递一个list<string>给一个参数为list<object>的函数将导致compile time错误。下面列表可以说明：

package com.brainysoftware.jdk5.app16;
import java

.util.arraylist;
import java

.util.list;
 
public class allowedtypetest {
  public static void doit(list<object> l) {
  }
  public static void main(string&#91;&#93; args) {
    list<string> mylist = new arraylist<string>();
    // 这里将产生一个错误
    doit(mylist);
  }
}

上面的代码无法编译，因为你试图传递一个错误的类型给函数doit。doit的参数是list<object>二你传递的参数是list<string>。
可以使用 ？ 通配符解决这个难题。list<?> 意味着一个对任何对象起作用的list。所以，doit可以改为：

public static void doit(list<?> l) {}

    在某些情况下你会考虑使用 ? 通配符。比如，你有一个printlist函数，这个函数打印一个list的所有成员，你想让这个函数对任何类型的list起作用时。否则，你只能累死累活的写很多printlist的重载函数。下面的列表引用了使用 ? 通配符的printlist函数。

package com.brainysoftware.jdk5.app16;
import java

.util.arraylist;
import java

.util.list;
 
public class wildcardtest {
 
  public static void printlist(list<?> list) {
    for (object element : list) {
      system.out.println(element);
    }
  }
  public static void main(string&#91;&#93; args) {
    list<string> list1 = new arraylist<string>();
    list1.add(&quot;hello&quot;);
    list1.add(&quot;world&quot;);
    printlist(list1);
 
    list<integer> list2 = new arraylist<integer>();
    list2.add(100);
    list2.add(200);
    printlist(list2);
  }
}

这些代码说明了在printlist函数中，list<?>表示各种类型的list对象。然而，请注意，在声明的时候使用 ? 通配符是不合法的，像这样：

list<?> mylist = new arraylist<?>(); // 不合法

如果你想创建一个接收任何类型对象的list，你可以使用object作为类型变量，就像这样：

list<object> mylist = new arraylist<object>();

在函数中使用界限通配符
在之前的章节中，你学会了通过传递不同的类型变量s来创建不同java 类型的泛型，但并不考虑类型变量s之间的继承关系。在很多情况下，你想一个函数有不同的list参数。比如，你有一个函数getaverage，他返回了一个list中成员的平均值。然而，如果你把list<number>作为getaverage的参数，你就没法传递list<integer> 或list<double>参数，因为list<number>和list<integer> 和list<double>不是同样的类型。

你能使用原型或使用通配符，但这样无法在编译时进行安全 类型检查，因为你能传递任何类型的list，比如list<string>的实例。你可以使用list<number>作为参数，但是你就只能传递list<number>给函数。但这样就使你的函数功能减少，因为你可能更多的时候要操作list<integer>或list<long>，而不是list<number>。

j2se 5.0增加了一个规则来解决了这种约束，这个规则就是允许你定义一个上界(upper bound) 类型变量.在这种方式中，你能传递一个类型或它的子类。在上面getaverage函数的例子中，你能传递一个list<number>或它的子类的实例，比如list<integer> or list<float>。

使用上界规则的语法这么定义的：generictype<? extends upperboundtype>. 比如，对getaverage函数的参数，你可以这么写list<? extends number>. 下面例子说明了如何使用这种规则。

package com.brainysoftware.jdk5.app16;
import java

.util.arraylist;
import java

.util.list;
public class boundedwildcardtest {
  public static double getaverage(list<? extends number> numberlist)
  {
    double total = 0.0;
    for (number number : numberlist)
      total += number.doublevalue();
    return total/numberlist.size();
  }
 
  public static void main(string&#91;&#93; args) {
    list<integer> integerlist = new arraylist<integer>();
    integerlist.add(3);
    integerlist.add(30);
    integerlist.add(300);
    system.out.println(getaverage(integerlist)); // 111.0
    list<double> doublelist = new arraylist<double>();
    doublelist.add(3.0);
    doublelist.add(33.0);
    system.out.println(getaverage(doublelist)); // 18.0
  }
}

由于有了上界规则，上面例子中的getaverage函数允许你传递一个list<number> 或一个类型变量是任何java .lang.number子类的list。

下界规则
关键字extends定义了一个类型变量的上界。通过使用super关键字，我们可以定义一个类型变量的下界，尽管使用的情况不多。比如，如果一个函数的参数是list<? super integer>，那么意味着你可以传递一个list<integer>的实例或者任何java .lang.integer的超类(superclass)。

创建泛型

前面的章节主要说明了如何使使用泛型，特别是集合框架 中的类。现在我们开始学习如何写自己的泛型。

基本上，除了声明一些你想要使用的类型变量s外，一个泛型和别的类没有什么区别。这些类型变量s位于类型后面的<>中。比如，下面的point就是个泛型。一个point对象代表了一个系统中的点，它有横坐标和纵坐标。通过使point泛型化，你能定义一个点实例的精确程度。比如，如果一个point对象需要非常精确，你就把double作为类型变量。否则，integer 就够了。

package com.brainysoftware.jdk5.app16;
public class point<t> {
  t x;
  t y;
  public point(t x, t y) {
    this.x = x;
    this.y = y;
  }
  public t getx() {
    return x;
  }
  public t gety() {
    return y;
  }
  public void setx(t x) {
    this.x = x;
  }
  public void sety(t y) {
    this.y = y;
  }
}

在这个例子中，t是point的类型变量 。t是getx和gety的返回值类型，也是setx和sety的参数类型。此外，构造函数结合两个t参数。
使用point类就像使用别的类一样。比如，下面的例子创建了两个point对象：ponint1和point2。前者把integer作为类型变量，而后者把double作为类型变量。

point<integer> point1 = new point<integer>(4, 2);
point1.setx(7);
point<double> point2 = new point<double>(1.3, 2.6);
point2.setx(109.91);

总结
泛型使代码在编译时有了更严格的类型检查。特别是在集合框架 中，泛型有两个作用。第一，他们增加了对集合类型在编译时的类型检查，所以集合类所能持有的类型对传递给它的参数类型起了限制作用。比如你创建了一个持有strings的java .util.list实例，那么他就将不能接受integers或别的类型。其次，当你从一个集合中取得一个元素时，泛型消除了类型转换的必要。
泛型能够在没有类型变量的情况下使用，比如，作为原型。这些措施让java 5之前的代码能够运行在jre 5中。但是，对新的应用程序，你最好不要使用原型，因为以后java 可能不支持他们。

你已经知道通过传递不同类型的类型变量给泛型可以产生不同的java 类型。就是说list<string>和list<object>的类型是不同的。尽管string是java .lang.object。但是传递一个list<string>给一个参数是list<object>的函数会参数会产生编译错误（compile error）。函数能用 ? 通配符使其接受任何类型的参数。list<?> 意味着任何类型的对象。
最后，你已经看到了写一个泛型和别的一般java 类没有什么区别。你只需要在类型名称后面的<>中声明一系列的类型变量s就行了。这些类型变量s就是返回值类型或者参数类型。根据惯例，一个类型变量用一个大写字母表示。


budi kurniawan是一个高级 j2ee 架构师和作家。作者：budi kurniawan
翻译：rr00       email：[e-mail]