java泛型详解

一、泛型类

二、泛型方法

三、类型变量限定

四、类型擦除

4.1与4.2：虚拟机中没有泛型

4.3：翻译泛型表达式

五、继承规则（通配符的上下限）

捕获通配符。

六、约束与局限性

大部分的泛型文章只涉及到泛型类与泛型方法等一些部分，在这一篇文章中，尽量对泛型有一个详细全面的基础描述，介绍实现自己的泛型需要了解的各种知识。

为什么使用泛型？

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。使用泛型机制编写的程序代码要比那些杂乱地使用Object变量，然后再进行类型强制转换的代码具有更好的安全性和可读性。泛型程序设计意味着代码可以被很多不同类型的对象所重用。

一、泛型类

一个泛型类就是一个具有一个或多个类型变量的类。

例如，定义一个名为Pair的泛型类

public class Pair<T>{private T first;private T second;}

Pair类引入一个类型变量T，用<>括起来，并放在类型后面。

例如，当你要声明一个Strng类型变量的Pair类时可以：

Pair<String> p；

代表：

public class Pair<String>{private Sting first;private Sting second;}

同样，当first与second的类型不一样时，也可以设计如下一个泛型类。

public class Pair<T，U>{private T first;private U second;}

声明时，Pair<Sting,Date>p;

注：在java库中，使用变量E表示集合的元素类型，K和V分别表示表的关键字与值，T（有时使用U和S）表示“任意类型”

二、泛型方法

除了定义一个泛型类之外，我们也可以定义一个泛型方法。泛型方法可以定义在普通类与泛型类当中。

在Pair类原有的基础上，我们再增加getter与setter方法。

public class Pair<T>{private T first;private T second;public <T> T getFirst(){return first;}public <T> setFirst(T first){this.first = first;}}

在泛型方法中，类型参数<T>放在修饰符（此处是public）后面，返回类型前面（此处是T）。

三、类型变量限定

有时候，我们需要对类型T做一些限定，比如传入的类型需要是能够进行比较排序的类型。

例如，我们定义一个找出最小值的泛型方法min，类型T是继承了Comparable接口的类型。

class sort{public static <T extendsComparable> T min(T[] a){T smallest = a[0];for(int i = 0;i < a.length;i++){//如果T不限定成是继承了comparable接口的类，则不能够保证传入的类型变量拥有compareTo方法，在程序运行时容易出错。If(smallest.compareTo(T[i]) > 0)Smallest = T[i];}}}

在java继承中，可以根据需要限定多个接口超类型，但最多限定一个类，限定类型用“&”分隔。

例如限定一个继承Comparable接口、Serializable接口与Pair类接口的子类类型，则min方法应该这么定义：

public static <T extends Pair & Comparable & Serializable>T min(T[] a){…}

注意：限定类时，类应该放在限定列表的第一个

四、类型擦除

首先，记住以下四点：

1、虚拟机（JVM）中，没有泛型，只有普通的类与方法；

2、所有的类型参数都用它们的限定类型替换；

3、为保持类型安全性，必要时插入强制类型转换（虚拟机自动完成此项工作）；

4、桥方法被合成来保持多态（虚拟机自动完成此项工作）；

下面将分别阐述以上四点

4.1与4.2：虚拟机中没有泛型

在虚拟机中，所有的类与方法都是普通类。无论何时定义一个泛型，在虚拟机中，都自动提供一个相应的原始类型（raw type）。原始类型的名字就是删去类型参数（<T>）后的泛型类型名。

例如前面的Pair<T>的原始类型名就是Pair。而类型变量T 就会被擦除，替换成Object。

public class Pair<T>{private T first;private T second;}

类型擦除后：

public class Pair{private Object first;private Object second;}

当T是有单个或者多个限定类型时，T被替换成限定列表的第一个：

class sort{

public static <T extendsComparable> T min(T[] a)

{

  T smallest = a[0];

  for(int i = 0;i < a.length;i++)

{

If(smallest.compareTo(T[i]) > 0)

  Smallest = T[i];

}

}

}

类型擦除后：

class sort{

public static Comparable min(Comparable [] a)

{

  Comparable smallest = a[0];

  for(int i = 0;i < a.length;i++)

{

If(smallest.compareTo(Comparable [i]) > 0)

  Smallest = [i];

}

}

}

4.3：翻译泛型表达式

给出如下的一个泛型类

class Pair<T>{

private Tfirst;

private T second;

public Pair（T first，T second）

{

this.first = first;

this.second = second;

}

public T getFIrst（）

{

return first;

}

}

当类型擦除后变成了

class Pair{

private Objectfirst;

private Objectsecond;

public Pair（Object first，Object second）

{

this.first = first;

this.second = second;

}

public Object getFIrst（）

{

return first;

}

}

考虑如下代码：

Pair<String> p = new Pair(“hello”,”world”);

String p1 = p.getFirst();

记住，由于类型擦除，Pair类里面的getFirst

public Object getFIrst（）

{

return first;

}

返回的是Object对象，编译器自动插入String的强制类型转换，类似于

String p1 = （Strng）p.getFirst();

4.4、桥方法

桥方法的存在是为了解决泛型方法类型擦除后产生的问题。

假设有一个类继承自Pair<String>

class PairChild extends Pair<String>{

  public void setFirst(String first)

{

//如果first是字符串“hello”，则调用父类的setFirst（）方法

If(first == “hello”)

  super.setFirst(first);

}

}

这段代码在类型擦除后变成了：

class PairChild extends Pair{

//注意此处的setFirst(String first)方法

  public void setFirst(String first)

{

//如果first是字符串“hello”，则调用父类的setFirst（）方法

If(first == “hello”)

  super.setFirst(first);

}

}

此时注意父类Pair

public class Pair<T>

{

private T first;

private T second;

public <T> setFirst(T first){

this.first = first;

}

}

类型擦除后变成：

public class Pair

{

private Objectfirst;

private Object second;

public void setFirst(Objectsecond){…}

}

这里有一个public voidsetFirst(Object second){…}方法。

子类PairChild继承了父类的public void setFirst(Object second)方法，同时自身又有一个public void setFirst(String first)，此时，setFirst方法有了多态。

那么当有以下代码时：

PairChlid pc = new PairChild（）；

pc.setFirst(“world”);

由于拥有父类参数的方法能传入子类，此时的pc.setFirst(“world”)应该调用public void setFirst(Object second)还是publicvoid setFirst(String first)方法呢？

为了避免这种疑惑，虚拟机在PairChlid类中生成一个桥方法

class PairChild extends Pair<String>{

//覆盖了父类的setFirst（Object first）方法的同时，调用了setFirst(String first)方法

public void setFirst(Object first){

setFirst(（String）first)；

}

public void setFirst(String first)

{

//如果first是字符串“hello”，则调用父类的setFirst（）方法

If(first == “hello”)

super.setFirst(first);

}

}