泛型是在Java5中加入的，是Java发布以来的最大变化。使用泛型可以避免在代码中杂乱的使用Object然后再强制类型转化，使得代码具有更好的安全性和可读性。尤其是在集合类中，比如ArrayList就是一个使用的非常广泛的泛型集合类。
1 什么是泛型
泛型程序设计（Generic Programming）以为着编写的代码可以被很多不同类型的对象所重用。比如，我们并不希望为了聚集String和File而分别设计不同的类，我们需要的是有一个可以聚集任何类型的集合类，事实上，ArrayList就可以聚集任何类型的对象，这就是一个泛型的实例。
在泛型之前，泛型程序设计是用继承实现的。ArrayList类只维护一个Object引用的数组：
- public class ArrayList
- {
- private Object[] elementData;
- ...
- public Object get(int i){...}
- public void add(Object o){...}
- }
- public class ArrayList
- {
- private Object[] elementData;
- ...
- public Object get(int i){...}
- public void add(Object o){...}
- }
public class ArrayList
{
private Object[] elementData;
...
public Object get(int i){...}
public void add(Object o){...}
}- ArrayList files=new ArrayList();
- ...
- String finename=(String)fines.get(0);
- ArrayList files=new ArrayList();
- ...
- String finename=(String)fines.get(0);
ArrayList files=new ArrayList();
...
String finename=(String)fines.get(0);此外，由于Object是所有类的始祖，当添加一个元素时没有错误检查，也就是说可以向数组列表中添加任何类的对象：
files.add(new File("..."));使用泛型可以很好的解决这个问题。泛型提供的解决方案就是类型参数（type parameters）。比如，ArrayList类有一个类型参数用来指示元素的类型：
ArrayList<String> files=new ArrayList<String>();这使得代码具有更好的可读性，一看就知道这个数组列表中存放的是String对象。
同时，还可以省略后面尖括号中的String：
ArrayList<String> files=new ArrayList<>();String filename=files.get(0);files.add(new File("..."));//ERROR2 定义简单的泛型类
一个泛型类就是具有一个或多个类型变量的类。这里使用一个简单的Pair类作为例子。下面是Pair的代码：
- package generic;
- public class Pair<T> {
- private T first;
- private T second;
- public Pair(){
- this.first=null;
- this.second=null;
- }
- public Pair(T first,T second){
- this.first=first;
- this.second=second;
- }
- public T getFirst() {
- return first;
- }
- public void setFirst(T first) {
- this.first = first;
- }
- public T getSecond() {
- return second;
- }
- public void setSecond(T second) {
- this.second = second;
- }
- @Override
- public String toString() {
- return "Pair [first=" + first + ", second=" + second + "]";
- }
- }
- package generic;
- public class Pair<T> {
- private T first;
- private T second;
- public Pair(){
- this.first=null;
- this.second=null;
- }
- public Pair(T first,T second){
- this.first=first;
- this.second=second;
- }
- public T getFirst() {
- return first;
- }
- public void setFirst(T first) {
- this.first = first;
- }
- public T getSecond() {
- return second;
- }
- public void setSecond(T second) {
- this.second = second;
- }
- @Override
- public String toString() {
- return "Pair [first=" + first + ", second=" + second + "]";
- }
- }
package generic;
public class Pair<T> {
private T first;
private T second;
public Pair(){
this.first=null;
this.second=null;
}
public Pair(T first,T second){
this.first=first;
this.second=second;
}
public T getFirst() {
return first;
}
public void setFirst(T first) {
this.first = first;
}
public T getSecond() {
return second;
}
public void setSecond(T second) {
this.second = second;
}
@Override
public String toString() {
return "Pair [first=" + first + ", second=" + second + "]";
}
}public class Pair<T,U>{...}private T first;Pair<String>Pair<String>()
Pair<String>(String,String)- String getFirst()
- String getSecond()
- void setFirst(String)
- void setSecond(String)
- String toString()
- String getFirst()
- String getSecond()
- void setFirst(String)
- void setSecond(String)
- String toString()
String getFirst()
String getSecond()
void setFirst(String)
void setSecond(String)
String toString()考虑下面的测试代码：
- public class GenericTest {
- public static void main(String[] args) {
- String[] words={"Mary","had","a","little","lamp"};
- Pair<String> mm=minmax(words);
- System.out.println(mm);
- }
- public static Pair<String> minmax(String[] a){
- if(a==null||a.length==0)return null;
- String min=a[0];
- String max=a[0];
- for(int i=1;i<a.length;i++)
- {
- if(min.compareTo(a[i])>0)min=a[i];
- if(max.compareTo(a[i])<0)max=a[i];
- }
- return new Pair<String>(min,max);
- }
- }
- public class GenericTest {
- public static void main(String[] args) {
- String[] words={"Mary","had","a","little","lamp"};
- Pair<String> mm=minmax(words);
- System.out.println(mm);
- }
- public static Pair<String> minmax(String[] a){
- if(a==null||a.length==0)return null;
- String min=a[0];
- String max=a[0];
- for(int i=1;i<a.length;i++)
- {
- if(min.compareTo(a[i])>0)min=a[i];
- if(max.compareTo(a[i])<0)max=a[i];
- }
- return new Pair<String>(min,max);
- }
- }
public class GenericTest {
public static void main(String[] args) {
String[] words={"Mary","had","a","little","lamp"};
Pair<String> mm=minmax(words);
System.out.println(mm);
}
public static Pair<String> minmax(String[] a){
if(a==null||a.length==0)return null;
String min=a[0];
String max=a[0];
for(int i=1;i<a.length;i++)
{
if(min.compareTo(a[i])>0)min=a[i];
if(max.compareTo(a[i])<0)max=a[i];
}
return new Pair<String>(min,max);
}
}Pair [first=Mary, second=little]
3 泛型方法
上面介绍了如何定义并使用一个泛型类。实际上，还可以定义一个带有类型参数的简单方法：
public static <T> T getMiddle(T... a)
{
return a[a.length/2];
}泛型方法可以定义在普通类中，也可以定义在泛型类中。
当调用一个泛型方法时，在方法名前的尖括号中放入具体的类型：
String middle=<String>getMiddle("a","b","c");大多数情况下，对泛型方法的类型引用没有问题。不过，有时候也会提示错误：
double middle=getMiddle(3.14,12,0);4 类型变量的限定
有时，类或方法需要对类型变量加以约束。比如，我们要计算数组中的最小元素：
- class ArrayAlg
- {
- public static <T> T min(T[] a)
- {
- if(a==null||a.length==0)return null;
- T smallest=a[0];
- for(int i=1;i<a.length;i++)
- if(smallest.compareTo(a[i])>0)smallest=a[i];
- return smallest;
- }
- }
- class ArrayAlg
- {
- public static <T> T min(T[] a)
- {
- if(a==null||a.length==0)return null;
- T smallest=a[0];
- for(int i=1;i<a.length;i++)
- if(smallest.compareTo(a[i])>0)smallest=a[i];
- return smallest;
- }
- }
class ArrayAlg
{
public static <T> T min(T[] a)
{
if(a==null||a.length==0)return null;
T smallest=a[0];
for(int i=1;i<a.length;i++)
if(smallest.compareTo(a[i])>0)smallest=a[i];
return smallest;
}
}解决的方法是将T限制为实现了Comparable接口的类。像这样：
public static <T extends Comparable> T min(T[] a)...一个类型变量或通配符（后面会介绍到）可以有多个限定：
T extends Comparable & Serializable在Java的继承中，可以根据需要拥有多个接口超类型，但限定中至多有一个类。如果用一个类作为限定，它必须是限定列表中的第一个。
5 泛型代码与虚拟机
虚拟机没有泛型类型对象，也就是说所有的类都是普通类。那么java是如何处理泛型的呢？
5.1 类型擦除
无论何时定义了一个泛型类型，都自动提供了一个相应的原始类型（raw type）。原始类型的名字就是删去类型参数的泛型类型名。擦除（erased）类型变量，并替换为限定类型（没有限定类型就用Object）。
比如前面的Pair<T>的原始类型如下：
- public class Pair {
- private Object first;
- private Object second;
- public Pair(){
- this.first=null;
- this.second=null;
- }
- public Pair(Object first,Object second){
- this.first=first;
- this.second=second;
- }
- public Object getFirst() {
- return first;
- }
- public void setFirst(Object first) {
- this.first = first;
- }
- public Object getSecond() {
- return second;
- }
- public void setSecond(Object second) {
- this.second = second;
- }
- @Override
- public String toString() {
- return "Pair [first=" + first + ", second=" + second + "]";
- }
- }
- public class Pair {
- private Object first;
- private Object second;
- public Pair(){
- this.first=null;
- this.second=null;
- }
- public Pair(Object first,Object second){
- this.first=first;
- this.second=second;
- }
- public Object getFirst() {
- return first;
- }
- public void setFirst(Object first) {
- this.first = first;
- }
- public Object getSecond() {
- return second;
- }
- public void setSecond(Object second) {
- this.second = second;
- }
- @Override
- public String toString() {
- return "Pair [first=" + first + ", second=" + second + "]";
- }
- }
public class Pair {
private Object first;
private Object second;
public Pair(){
this.first=null;
this.second=null;
}
public Pair(Object first,Object second){
this.first=first;
this.second=second;
}
public Object getFirst() {
return first;
}
public void setFirst(Object first) {
this.first = first;
}
public Object getSecond() {
return second;
}
public void setSecond(Object second) {
this.second = second;
}
@Override
public String toString() {
return "Pair [first=" + first + ", second=" + second + "]";
}
}在程序中可使用不同类型的Pair，比如Pair<String>、Pair<Date>，但擦除类型后就变为原始的Pair类型了。
原始类型用第一个限定的类型变量来替换，如果没有给定限定就用Object替换。假如有下面的泛型：
- public class Interval<T extends Comparable & Serializable> implements Seriallizable
- {
- private T lower;
- private T upper;
- ...
- public Interval(T first,T second){
- if(first.compareTo(second)<=0){
- lower=first;
- upper=second;
- }
- else{
- lower=second;
- upper=first;
- }
- }
- }
- public class Interval<T extends Comparable & Serializable> implements Seriallizable
- {
- private T lower;
- private T upper;
- ...
- public Interval(T first,T second){
- if(first.compareTo(second)<=0){
- lower=first;
- upper=second;
- }
- else{
- lower=second;
- upper=first;
- }
- }
- }
public class Interval<T extends Comparable & Serializable> implements Seriallizable
{
private T lower;
private T upper;
...
public Interval(T first,T second){
if(first.compareTo(second)<=0){
lower=first;
upper=second;
}
else{
lower=second;
upper=first;
}
}
}- public class Interval implements Serializable
- {
- private Comparable lower;
- private Comparable upper;
- ...
- public Interval(Comparable first,Comparable second){...}
- }
- public class Interval implements Serializable
- {
- private Comparable lower;
- private Comparable upper;
- ...
- public Interval(Comparable first,Comparable second){...}
- }
public class Interval implements Serializable
{
private Comparable lower;
private Comparable upper;
...
public Interval(Comparable first,Comparable second){...}
}5.2 翻译泛型表达式
当程序调用泛型方法时，如果擦除返回类型，编译器将插入强制类型转换。比如：
Pair<Student> buddies=...;
Student buddy=buddies.getFirst();（1）对原始方法Pair.getFirst的调用；
（2）将返回的Object类型强制转换为Student类型。
当存取一个泛型域时也要插入强制类型转换。假设Pair的first和second域都是公有的，下面的表达式：
Student buddy=buddies.first;5.3 翻译泛型方法
对泛型方法也会擦除。比如下面的泛型方法：
public static <T extends Comparable> T min(T[] a)public static Comparable min(Comparable[] a)方法的擦除带来了来两个问题。看看下面这个示例：
- import java.util.*;
- public class DateInterval extends Pair<Date>
- {
- public void setSecond(Date second){
- if(second.compareTo(getFirst())>0)
- super.setSecond(second);
- }
- }
- import java.util.*;
- public class DateInterval extends Pair<Date>
- {
- public void setSecond(Date second){
- if(second.compareTo(getFirst())>0)
- super.setSecond(second);
- }
- }
import java.util.*;
public class DateInterval extends Pair<Date>
{
public void setSecond(Date second){
if(second.compareTo(getFirst())>0)
super.setSecond(second);
}
}来看看擦除后的结果，使用javap -private DateInterval命令：
可以看到，里面有两个setSecond方法，一个参数类型是Object，另一个是Date。
参数类型是Date的好理解，是DateInterval擦除后的方法。那么类型是Object的呢？
其实这个方法是从Pair继承来的。
这显然是一个不同的方法。不过，这不应该不一样。比如：
- DateInterval interval=new Dateinterval(...);
- Pair<Date> pair=interval;//OK
- pair.setSecond(aDate);
- DateInterval interval=new Dateinterval(...);
- Pair<Date> pair=interval;//OK
- pair.setSecond(aDate);
DateInterval interval=new Dateinterval(...);
Pair<Date> pair=interval;//OK
pair.setSecond(aDate);为了解决这个问题，编译器在DateInterval类中生成了一个桥方法（bridge method）：
public void setSecond(Object second){
setSecond((Date)second);
}第二个问题是，有时这个生成的桥方法可能会很奇怪，超出我们对一般方法的认识。假设DateInterval也覆盖了getSetSecond方法：
- import java.util.*;
- public class DateInterval extends Pair<Date>
- {
- public void setSecond(Date second){
- if(second.compareTo(getFirst())>0)
- super.setSecond(second);
- }
- public Date getSecond(){
- return super.getSecond();
- }
- }
- import java.util.*;
- public class DateInterval extends Pair<Date>
- {
- public void setSecond(Date second){
- if(second.compareTo(getFirst())>0)
- super.setSecond(second);
- }
- public Date getSecond(){
- return super.getSecond();
- }
- }
import java.util.*;
public class DateInterval extends Pair<Date>
{
public void setSecond(Date second){
if(second.compareTo(getFirst())>0)
super.setSecond(second);
}
public Date getSecond(){
return super.getSecond();
}
}使用javap查看擦除后的结果：
结果显示有下面这两个方法：
Date getSecond()
Object getSecond()奇怪的是，这两个方法只有返回类型不同，而在Java中，这样编写代码时不合法的。不过，在虚拟机中，用参数类型和返回类型确定一个方法。因此，编译器可能产生两个仅返回类型不同的方法字节码，虚拟机能够正确处理这一情况。
下面是关于泛型转换的事实：
- 虚拟机中没有泛型，只有普通的类和方法；
- 所有的类型参数都用它们的限定类型替换；
- 桥方法被合成用来保持多态；
- 为保持类型安全性，必要时插入强制类型转换；
6 约束与局限
使用Java泛型时可能会遇到一些局限与限制，大多数限制都是由类型擦除引起的。
6.1 不能用基本类型实例化类型参数
不能使用类型参数代替基本类型。Java有8个基本类型，分别是：byte、short、int、long、float、double、char和boolean。因此，没有Pair<double>，只有Pair<Double>。原因就是类型擦除，因为擦除后，Pair类含有Object类型的域，而Object不能存储double的值。
不能使用基本类型，但是可以使用它们的包装器类型，比如Integer、Boolean等。
6.2 运行时类型查询只适用于原始类型
虚拟机中的对象总有一个特定的非泛型类型。因此，所有的类型查询只产生原始类型。比如：
if(a instanceof Pair<String>)//ERROR实际上仅仅测试a是否是任意类型的一个Pair。下面的测试也是如此：
if(a instanceof Pair<T>)//ERRORPair<String> p=(Pair<String>)a;//WARNING同样，getClass方法总是返回一个原始类型：
- Pair<String> stringPair=...;
- Pair<Student> studentPair=...;
- if(stringPair.getClass()==studentPair.getClass())//true
- Pair<String> stringPair=...;
- Pair<Student> studentPair=...;
- if(stringPair.getClass()==studentPair.getClass())//true
Pair<String> stringPair=...;
Pair<Student> studentPair=...;
if(stringPair.getClass()==studentPair.getClass())//true6.3 不能创建参数化类型的数组
不能实例化参数化类型的数组，例如：
Pair<String>[] table=new Pair<String>[10];//ERRORObject[] objarray=table;objarray[0]="Hello";不过对于泛型类型，擦除会使这种机制失效：
objarray[0]=new Pair<Student>();需要说明的是，只是不允许创建这些数组，而声明类型为Pair<String>[]的变量仍是合法的。不过不能使用new Pair<String>[10]初始化这个变量。
6.4 Varags警告
在上一节中已经知道，Java不支持泛型类型的数组。在这里我们讨论一个相关的问题：向参数可变的方法传递一个泛型类型的实例。
下面的方法是将一个将ts中的元素添加到一个Collection集合中：
- public static <T> void addAll(Collection<T> coll,T...ts){
- for(T t:ts){
- coll.add(t);
- }
- }
- public static <T> void addAll(Collection<T> coll,T...ts){
- for(T t:ts){
- coll.add(t);
- }
- }
public static <T> void addAll(Collection<T> coll,T...ts){
for(T t:ts){
coll.add(t);
}
}看看下面的调用：
- Collection<Pair<String>> table=new ArrayList<Pair<String>>();
- Pair<String> one=new Pair<String>("Hello","World");
- Pair<String> two=new Pair<String>("Hello","Java");
- addAll(table,one,two);
- System.out.println(table);
- Collection<Pair<String>> table=new ArrayList<Pair<String>>();
- Pair<String> one=new Pair<String>("Hello","World");
- Pair<String> two=new Pair<String>("Hello","Java");
- addAll(table,one,two);
- System.out.println(table);
Collection<Pair<String>> table=new ArrayList<Pair<String>>();
Pair<String> one=new Pair<String>("Hello","World");
Pair<String> two=new Pair<String>("Hello","Java");
addAll(table,one,two);
System.out.println(table);为了调用这个方法，Java虚拟机必须建立一个Pair<String>数组。不过，这时只会有一个警告，而不是错误：
可以采用两种方法来抑制这个警告。一种方法是为包含addAll调用的方法增加标注@SuppressWarning("unchecked")。或者在Java SE 7中，还可以使用@SafeVaragrs直接标注addAll方法：
- @SafeVargars
- public static <T> void addAll(Collection<T> coll,T...ts){...}
- @SafeVargars
- public static <T> void addAll(Collection<T> coll,T...ts){...}
@SafeVargars
public static <T> void addAll(Collection<T> coll,T...ts){...}上述调用的结果如下：
[Pair [first=Hello, second=World], Pair [first=Hello, second=Java]]
6.5 不能实例化类型变量
不能使用像new T(...)，new T[...]或T.class这样的表达式中的类型变量。比如，下面的Pair<T>构造器就是非法的：
public Pair(){first=new T();second=new T();}//ERROR由于不能使用T.class，所以如下的代码是非法的：
first=T.class.newInstance();//ERROR- public static <T> Pair<T> makePair(Class<T> cl)
- {
- try{
- return new Pair<>(cl.newInstance(),cl.newInstance());
- }catch(Exception e){
- return null;
- }
- }
- public static <T> Pair<T> makePair(Class<T> cl)
- {
- try{
- return new Pair<>(cl.newInstance(),cl.newInstance());
- }catch(Exception e){
- return null;
- }
- }
public static <T> Pair<T> makePair(Class<T> cl)
{
try{
return new Pair<>(cl.newInstance(),cl.newInstance());
}catch(Exception e){
return null;
}
}Pair<String> pair=Pair.makePair(String.class);不能构造一个泛型数组：
- public static <T extends Comparable> T[] minmax(T[] a)
- {
- T[] mm=new T[2];//ERROR
- ...
- }
- public static <T extends Comparable> T[] minmax(T[] a)
- {
- T[] mm=new T[2];//ERROR
- ...
- }
public static <T extends Comparable> T[] minmax(T[] a)
{
T[] mm=new T[2];//ERROR
...
}如果数组仅仅作为一个类的私有实例域，就可以将这个数组声明为Object[]，并在获取元素时进行类型转换。
其实，ArrayList类就是这么实现的：
Object[] elementData;- @SuppressWarnings("unchecked")
- E elementData(int index) {
- return (E) elementData[index];
- }
- /**
- * Returns the element at the specified position in this list.
- *
- * @param index index of the element to return
- * @return the element at the specified position in this list
- * @throws IndexOutOfBoundsException {@inheritDoc}
- */
- public E get(int index) {
- rangeCheck(index);
- return elementData(index);
- }
- @SuppressWarnings("unchecked")
- E elementData(int index) {
- return (E) elementData[index];
- }
- /**
- * Returns the element at the specified position in this list.
- *
- * @param index index of the element to return
- * @return the element at the specified position in this list
- * @throws IndexOutOfBoundsException {@inheritDoc}
- */
- public E get(int index) {
- rangeCheck(index);
- return elementData(index);
- }
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}假如minmax方法返回一个长度为2的数组，而不是一个Pair，可能这样实现：
- public static <T extends Comparable> T[] minmax(T... a)
- {
- Object[] mm=new Object[2];
- T min=a[0];
- T max=a[0];
- for(int i=1;i<a.length;i++)
- {
- if(min.compareTo(a[i])>0)min=a[i];
- if(max.compareTo(a[i])<0)max=a[i];
- }
- mm[0]=min;
- mm[1]=max;
- return (T[])mm;
- }
- public static <T extends Comparable> T[] minmax(T... a)
- {
- Object[] mm=new Object[2];
- T min=a[0];
- T max=a[0];
- for(int i=1;i<a.length;i++)
- {
- if(min.compareTo(a[i])>0)min=a[i];
- if(max.compareTo(a[i])<0)max=a[i];
- }
- mm[0]=min;
- mm[1]=max;
- return (T[])mm;
- }
public static <T extends Comparable> T[] minmax(T... a)
{
Object[] mm=new Object[2];
T min=a[0];
T max=a[0];
for(int i=1;i<a.length;i++)
{
if(min.compareTo(a[i])>0)min=a[i];
if(max.compareTo(a[i])<0)max=a[i];
}
mm[0]=min;
mm[1]=max;
return (T[])mm;
}String[] ss=minmax("Tom","Dick","Harry");编译时不会有任何警告。但是当Object引用赋给String[]变量时，将会发生ClassCastException异常。结果如下：
这时，可以利用反射，调用Array.newInstance：
T[] mm=(T[])Array.newInstance(a.getClass().getComponentType(), 2);Dick
Tom
ArrayList中有两个toArray方法。第一种返回一个Object[]数组：
- public Object[] toArray() {
- return Arrays.copyOf(elementData, size);
- }
- public Object[] toArray() {
- return Arrays.copyOf(elementData, size);
- }
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}- public <T> T[] toArray(T[] a) {
- if (a.length < size)
- // Make a new array of a's runtime type, but my contents:
- return (T[]) Arrays.copyOf(elementData, size, a.getClass());
- System.arraycopy(elementData, 0, a, 0, size);
- if (a.length > size)
- a[size] = null;
- return a;
- }
- public <T> T[] toArray(T[] a) {
- if (a.length < size)
- // Make a new array of a's runtime type, but my contents:
- return (T[]) Arrays.copyOf(elementData, size, a.getClass());
- System.arraycopy(elementData, 0, a, 0, size);
- if (a.length > size)
- a[size] = null;
- return a;
- }
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}6.6 泛型类的静态上下文中类型变量无效
不能在静态域或方法中引用类型变量。比如，下面的代码将无效：
- public class Singleton<T>
- {
- private static T singleInstance;//ERROR
- publiv static T getSingleInstance()//ERROR
- {
- if(singleInstance==null) construct new instance of T
- return singleInstance;
- }
- }
- public class Singleton<T>
- {
- private static T singleInstance;//ERROR
- publiv static T getSingleInstance()//ERROR
- {
- if(singleInstance==null) construct new instance of T
- return singleInstance;
- }
- }
public class Singleton<T>
{
private static T singleInstance;//ERROR
publiv static T getSingleInstance()//ERROR
{
if(singleInstance==null) construct new instance of T
return singleInstance;
}
}如果这个程序能够运行的话，就可以声明一个Singleton<Random>共享随机数生成器，声明一个Singleton<JFileChooser>共享文件选择器对话框。遗憾的是，这个程序无法工作。擦除类型后，只剩下Singleton类，它只包含一个singleInstance域。因此，禁止使用带有类型变量的静态域和方法。
6.7 注意擦除后的冲突
当泛型类型被擦除时，可能会导致名字冲突。比如将下面的equals方法添加到Pair<T>中：
- public boolean equals(T value) {
- return first.equals(value) && second.equals(value);
- }
- public boolean equals(T value) {
- return first.equals(value) && second.equals(value);
- }
public boolean equals(T value) {
return first.equals(value) && second.equals(value);
}boolean equals(String)
boolean equals(Object)不过，类型擦除后，第一个equals方法将变为：
boolean equals(Object)
解决的办法就是重新命名引发冲突的方法。
对于擦除后引起的名字冲突，还有一种可能，即擦除后生成的桥方法之间产生冲突。
这是有可能的，比如：
- class Calendar implements Comparable<Calendar>{...}
- class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...}//ERROR
- class Calendar implements Comparable<Calendar>{...}
- class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...}//ERROR
class Calendar implements Comparable<Calendar>{...}
class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...}//ERROR实现了Comparable<X>的类可以获得一个如下的桥方法：
public intcompareTo(Object other){
return compareTo((X)other);
}因此，泛型规范还提到另一个原则：
要想支持擦除的转换，就需要强行限制一个类或类型变量不能同时成为两个接口类型的子类，而这两个接口是同一个接口的不同参数化。
比如上面的GregorianCalendar，是Comparable<Calendar>和Comparable<GregorianCalendar>的子类，这两个接口是同一个接口的不同参数化，因此出错。
7 泛型类型的继承规则
在使用泛型时，还需要了解一些有关继承和子类型的准则。考虑一个类和一个子类，比如Employee和Manager，Manager继承自Employee，那么Pair<Manager>是Pair<Employee>的一个子类么？不是。
下面的代码将不能编译成功：
- Manager[] top=...;
- Pair<Employee> result=ArrayAlg.minmax(top);//ERROR
- Manager[] top=...;
- Pair<Employee> result=ArrayAlg.minmax(top);//ERROR
Manager[] top=...;
Pair<Employee> result=ArrayAlg.minmax(top);//ERROR即，无论S与T有什么关系，通常Pair<S>与Pair<T>没有什么关系：
这看起来可能非常严格，但对于类型安全来说非常必要。假设允许将Pair<Manager>转换为Pair<Employee>。看下面的代码：
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair<Employee> employeeBuddies=managerBuddies;
- employeeBuddies.setFirst(lowlyEmployee);
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair<Employee> employeeBuddies=managerBuddies;
- employeeBuddies.setFirst(lowlyEmployee);
Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
Pair<Employee> employeeBuddies=managerBuddies;
employeeBuddies.setFirst(lowlyEmployee);这显示了泛型和数组之间的重要区别。可以将一个Manager[]数组赋给一个类型为Employee[]的变量：
- Manager[] managerBuddies={ceo,cfo};
- Employee[] employeeBuddies=managerBuddies;
- Manager[] managerBuddies={ceo,cfo};
- Employee[] employeeBuddies=managerBuddies;
Manager[] managerBuddies={ceo,cfo};
Employee[] employeeBuddies=managerBuddies;永远可以将参数化类型转换为一个原始类型。比如Pair<Employee>是原始类型Pair的一个子类型。
转换成原始类型之后也可能会出错：
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair rawBuddies=managerBuddies;//OK
- rawBuddies.setFirst(new File("..."));//only a cimpile-time warning
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair rawBuddies=managerBuddies;//OK
- rawBuddies.setFirst(new File("..."));//only a cimpile-time warning
Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
Pair rawBuddies=managerBuddies;//OK
rawBuddies.setFirst(new File("..."));//only a cimpile-time warning
8 通配符类型
8.1 通配符
泛型中使用？表示通配符类型。比如：
Pair<? extends Employee>假设要编写一个打印雇员对的方法：
- public static void printBuddies(Pair<Employee> p){
- Employee first=p.getFirst();
- Employee second=p.getSecond();
- System.out.println(first.getName()+" and "+second.getName()+" are buddies.");
- }
- public static void printBuddies(Pair<Employee> p){
- Employee first=p.getFirst();
- Employee second=p.getSecond();
- System.out.println(first.getName()+" and "+second.getName()+" are buddies.");
- }
public static void printBuddies(Pair<Employee> p){
Employee first=p.getFirst();
Employee second=p.getSecond();
System.out.println(first.getName()+" and "+second.getName()+" are buddies.");
}public static void printBuddies(Pair<? extends Employee> p)
现在考虑下面的代码：
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair<? extends Employee> wildcardBuddies=managerBuddies;//OK
- wildcardBuddies.setFirst(lowlyEmployee);//compile-time error
- Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
- Pair<? extends Employee> wildcardBuddies=managerBuddies;//OK
- wildcardBuddies.setFirst(lowlyEmployee);//compile-time error
Pair<Manager> managerBuddies=new Pair<>(ceo,cfo);
Pair<? extends Employee> wildcardBuddies=managerBuddies;//OK
wildcardBuddies.setFirst(lowlyEmployee);//compile-time error看一下Pair<? extends Employee>，里面似乎有这两个方法：
? extends Employee getFirst()
void setFirst(? extends Employee)使用getFirst方法就没有问题了，将getFirst方法的返回值赋给一个Employee的引用完全合法。
8.2 通配符的超类型限定
通配符限定于类型变量限定很像，但是，还有一个附加的能力，即可以指定一个超类型（supertype bound），如下：
? super Manager这个行为与上一个通配符限定正好相反。可以为方法提供参数，但不能使用返回值。比如，Pair<? super Manager>有如下的方法：
void setFirst(? super Manager)
? super Manager getFirst()下面是一个简单的例子，有一个Manager数组，把工资最高和最低的放在一个Pair中，Pair的类型是什么呢？在这里，Pair<Employee>是合理的，Pair<Object>也是合理的，它们的关系如下：
这个方法如下：
- public static void minmaxBonus(Manager[] a,Pair<? super Manager> result){
- if(a==null || a.length==0)return;
- Manager min=a[0];
- Manager max=a[0];
- for(int i=1;i<a.length;i++){
- if(min.getSalary()>a[i].getSalary())min=a[i];
- if(max.getSalary()<a[i].getSalary())max=a[i];
- }
- result.setFirst(min);
- result.setSecond(max);
- }
- public static void minmaxBonus(Manager[] a,Pair<? super Manager> result){
- if(a==null || a.length==0)return;
- Manager min=a[0];
- Manager max=a[0];
- for(int i=1;i<a.length;i++){
- if(min.getSalary()>a[i].getSalary())min=a[i];
- if(max.getSalary()<a[i].getSalary())max=a[i];
- }
- result.setFirst(min);
- result.setSecond(max);
- }
public static void minmaxBonus(Manager[] a,Pair<? super Manager> result){
if(a==null || a.length==0)return;
Manager min=a[0];
Manager max=a[0];
for(int i=1;i<a.length;i++){
if(min.getSalary()>a[i].getSalary())min=a[i];
if(max.getSalary()<a[i].getSalary())max=a[i];
}
result.setFirst(min);
result.setSecond(max);
}拿一个不恰当的比喻，Pair<? extends Employee>限定的是<=Employee，即Employee及子类；而Pair<? super Manager>限定的是>=Manager，即Manager及超类。
8.3 无限定通配符
还可以使用无限定通配符，比如Pair<?>。看起来这和原始的Pair一样，实际上有很大的不同。类型Pair<?>有如下的方法：
? getFirst()
void setFirst(?)不过，对Pair<?>类的setFirst，可以用null调用。
Pair<?>有什么用？它对于许多简单的操作很有用。比如，下面的方法用来测试一个pair是否包含一个null引用，它不需要实际的类型：
- public static boolean hasNulls(Pair<?> p)
- {
- return p.getFirst()==null || p.getSecond()==null;
- }
- public static boolean hasNulls(Pair<?> p)
- {
- return p.getFirst()==null || p.getSecond()==null;
- }
public static boolean hasNulls(Pair<?> p)
{
return p.getFirst()==null || p.getSecond()==null;
}9 泛型和反射
9.1 使用Class<T>参数进行类型匹配
有时，匹配泛型方法中的Class<T>参数的类型变量很有使用价值：
- public static <T> Pair<T> makePair(Class<T> c)throws InstantiationException,IllegalAccessException
- {
- return new Pair<>(c.newInstance(),c.newInstance());
- }
- public static <T> Pair<T> makePair(Class<T> c)throws InstantiationException,IllegalAccessException
- {
- return new Pair<>(c.newInstance(),c.newInstance());
- }
public static <T> Pair<T> makePair(Class<T> c)throws InstantiationException,IllegalAccessException
{
return new Pair<>(c.newInstance(),c.newInstance());
}makePair(Employee.class);9.2 虚拟机中的泛型类型信息
Java泛型在虚拟机中会擦除泛型类型，但是，擦除的类仍保留一些泛型祖先的记忆。例如，原始的Pair类知道源于泛型类Pair<T>。
泛型方法：
public static <T extends Comparable<? super T>> T min(T[] a)public static Comparable min(Comparable[] a)- 这个泛型方法有一个叫做T的类型参数；
- 这个类型参数有一个子类型限定，其本身又是一个泛型类型；
- 这个限定类型有一个通配符参数；
- 这个通配符参数有一个超类型限定；
- 这个泛型方法有一个泛型数组参数；
对于虚拟机来说，需要重新构造实现者声明的泛型类型以及方法中的所有内容。但是，不会知道对于特定的对象或方法调用，如果解释类型参数。
为了表达泛型类型声明，JavaSE 5在java.lang.reflect包中提供了一个新的的接口Type。这个接口有下列子类型：
- Class类，描述具体类型；
- TypeVariable接口，描述类型变量（比如T extends Comparable<? super T>）；
- WildcardType接口，描述通配符（比如? super T）；
- ParameterizedType接口，描述泛型类或接口类型（比如Comparable<? extends T>）；
- GenericArrayType接口，描述泛型数组（如T[]）；
下图是继承层次：
下面的代码可以打印一个泛型类的基本信息：
- import java.lang.reflect.*;
- import java.util.*;
- public class GenericReflection {
- public static void main(String[] args)
- {
- // read class name from command line args or user input
- String name;
- if (args.length > 0) name = args[0];
- else
- {
- Scanner in = new Scanner(System.in);
- System.out.println("Enter class name (e.g. java.util.Collections): ");
- name = in.next();
- }
- try
- {
- // print generic info for class and public methods
- Class<?> cl = Class.forName(name);
- printClass(cl);
- for (Method m : cl.getDeclaredMethods())
- printMethod(m);
- }
- catch (ClassNotFoundException e)
- {
- e.printStackTrace();
- }
- }
- public static void printClass(Class<?> cl)
- {
- System.out.print(cl);
- printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
- Type sc = cl.getGenericSuperclass();
- if (sc != null)
- {
- System.out.print(" extends ");
- printType(sc, false);
- }
- printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
- System.out.println();
- }
- public static void printMethod(Method m)
- {
- String name = m.getName();
- System.out.print(Modifier.toString(m.getModifiers()));
- System.out.print(" ");
- printTypes(m.getTypeParameters(), "<", ", ", "> ", true);
- printType(m.getGenericReturnType(), false);
- System.out.print(" ");
- System.out.print(name);
- System.out.print("(");
- printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
- System.out.println(")");
- }
- public static void printTypes(Type[] types, String pre, String sep, String suf,
- boolean isDefinition)
- {
- if (pre.equals(" extends ") && Arrays.equals(types, new Type[] { Object.class })) return;
- if (types.length > 0) System.out.print(pre);
- for (int i = 0; i < types.length; i++)
- {
- if (i > 0) System.out.print(sep);
- printType(types[i], isDefinition);
- }
- if (types.length > 0) System.out.print(suf);
- }
- public static void printType(Type type, boolean isDefinition)
- {
- if (type instanceof Class)
- {
- Class<?> t = (Class<?>) type;
- System.out.print(t.getName());
- }
- else if (type instanceof TypeVariable)
- {
- TypeVariable<?> t = (TypeVariable<?>) type;
- System.out.print(t.getName());
- if (isDefinition)
- printTypes(t.getBounds(), " extends ", " & ", "", false);
- }
- else if (type instanceof WildcardType)
- {
- WildcardType t = (WildcardType) type;
- System.out.print("?");
- printTypes(t.getUpperBounds(), " extends ", " & ", "", false);
- printTypes(t.getLowerBounds(), " super ", " & ", "", false);
- }
- else if (type instanceof ParameterizedType)
- {
- ParameterizedType t = (ParameterizedType) type;
- Type owner = t.getOwnerType();
- if (owner != null)
- {
- printType(owner, false);
- System.out.print(".");
- }
- printType(t.getRawType(), false);
- printTypes(t.getActualTypeArguments(), "<", ", ", ">", false);
- }
- else if (type instanceof GenericArrayType)
- {
- GenericArrayType t = (GenericArrayType) type;
- System.out.print("");
- printType(t.getGenericComponentType(), isDefinition);
- System.out.print("[]");
- }
- }
- }
- import java.lang.reflect.*;
- import java.util.*;
- public class GenericReflection {
- public static void main(String[] args)
- {
- // read class name from command line args or user input
- String name;
- if (args.length > 0) name = args[0];
- else
- {
- Scanner in = new Scanner(System.in);
- System.out.println("Enter class name (e.g. java.util.Collections): ");
- name = in.next();
- }
- try
- {
- // print generic info for class and public methods
- Class<?> cl = Class.forName(name);
- printClass(cl);
- for (Method m : cl.getDeclaredMethods())
- printMethod(m);
- }
- catch (ClassNotFoundException e)
- {
- e.printStackTrace();
- }
- }
- public static void printClass(Class<?> cl)
- {
- System.out.print(cl);
- printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
- Type sc = cl.getGenericSuperclass();
- if (sc != null)
- {
- System.out.print(" extends ");
- printType(sc, false);
- }
- printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
- System.out.println();
- }
- public static void printMethod(Method m)
- {
- String name = m.getName();
- System.out.print(Modifier.toString(m.getModifiers()));
- System.out.print(" ");
- printTypes(m.getTypeParameters(), "<", ", ", "> ", true);
- printType(m.getGenericReturnType(), false);
- System.out.print(" ");
- System.out.print(name);
- System.out.print("(");
- printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
- System.out.println(")");
- }
- public static void printTypes(Type[] types, String pre, String sep, String suf,
- boolean isDefinition)
- {
- if (pre.equals(" extends ") && Arrays.equals(types, new Type[] { Object.class })) return;
- if (types.length > 0) System.out.print(pre);
- for (int i = 0; i < types.length; i++)
- {
- if (i > 0) System.out.print(sep);
- printType(types[i], isDefinition);
- }
- if (types.length > 0) System.out.print(suf);
- }
- public static void printType(Type type, boolean isDefinition)
- {
- if (type instanceof Class)
- {
- Class<?> t = (Class<?>) type;
- System.out.print(t.getName());
- }
- else if (type instanceof TypeVariable)
- {
- TypeVariable<?> t = (TypeVariable<?>) type;
- System.out.print(t.getName());
- if (isDefinition)
- printTypes(t.getBounds(), " extends ", " & ", "", false);
- }
- else if (type instanceof WildcardType)
- {
- WildcardType t = (WildcardType) type;
- System.out.print("?");
- printTypes(t.getUpperBounds(), " extends ", " & ", "", false);
- printTypes(t.getLowerBounds(), " super ", " & ", "", false);
- }
- else if (type instanceof ParameterizedType)
- {
- ParameterizedType t = (ParameterizedType) type;
- Type owner = t.getOwnerType();
- if (owner != null)
- {
- printType(owner, false);
- System.out.print(".");
- }
- printType(t.getRawType(), false);
- printTypes(t.getActualTypeArguments(), "<", ", ", ">", false);
- }
- else if (type instanceof GenericArrayType)
- {
- GenericArrayType t = (GenericArrayType) type;
- System.out.print("");
- printType(t.getGenericComponentType(), isDefinition);
- System.out.print("[]");
- }
- }
- }
import java.lang.reflect.*;
import java.util.*;
public class GenericReflection {
public static void main(String[] args)
{
// read class name from command line args or user input
String name;
if (args.length > 0) name = args[0];
else
{
Scanner in = new Scanner(System.in);
System.out.println("Enter class name (e.g. java.util.Collections): ");
name = in.next();
}
try
{
// print generic info for class and public methods
Class<?> cl = Class.forName(name);
printClass(cl);
for (Method m : cl.getDeclaredMethods())
printMethod(m);
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
}
public static void printClass(Class<?> cl)
{
System.out.print(cl);
printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
Type sc = cl.getGenericSuperclass();
if (sc != null)
{
System.out.print(" extends ");
printType(sc, false);
}
printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
System.out.println();
}
public static void printMethod(Method m)
{
String name = m.getName();
System.out.print(Modifier.toString(m.getModifiers()));
System.out.print(" ");
printTypes(m.getTypeParameters(), "<", ", ", "> ", true);
printType(m.getGenericReturnType(), false);
System.out.print(" ");
System.out.print(name);
System.out.print("(");
printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
System.out.println(")");
}
public static void printTypes(Type[] types, String pre, String sep, String suf,
boolean isDefinition)
{
if (pre.equals(" extends ") && Arrays.equals(types, new Type[] { Object.class })) return;
if (types.length > 0) System.out.print(pre);
for (int i = 0; i < types.length; i++)
{
if (i > 0) System.out.print(sep);
printType(types[i], isDefinition);
}
if (types.length > 0) System.out.print(suf);
}
public static void printType(Type type, boolean isDefinition)
{
if (type instanceof Class)
{
Class<?> t = (Class<?>) type;
System.out.print(t.getName());
}
else if (type instanceof TypeVariable)
{
TypeVariable<?> t = (TypeVariable<?>) type;
System.out.print(t.getName());
if (isDefinition)
printTypes(t.getBounds(), " extends ", " & ", "", false);
}
else if (type instanceof WildcardType)
{
WildcardType t = (WildcardType) type;
System.out.print("?");
printTypes(t.getUpperBounds(), " extends ", " & ", "", false);
printTypes(t.getLowerBounds(), " super ", " & ", "", false);
}
else if (type instanceof ParameterizedType)
{
ParameterizedType t = (ParameterizedType) type;
Type owner = t.getOwnerType();
if (owner != null)
{
printType(owner, false);
System.out.print(".");
}
printType(t.getRawType(), false);
printTypes(t.getActualTypeArguments(), "<", ", ", ">", false);
}
else if (type instanceof GenericArrayType)
{
GenericArrayType t = (GenericArrayType) type;
System.out.print("");
printType(t.getGenericComponentType(), isDefinition);
System.out.print("[]");
}
}
}class Pair<T> extends java.lang.Object
public java.lang.String toString()
public T getFirst()
public T getSecond()
public void setSecond(T)
public void setFirst(T)
扫一扫
496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
