JAVA泛型详解

7.*泛型

我们知道，使用变量之前要定义，定义一个变量时必须要指明它的数据类型，什么样的数据类型赋什么样的值。下面我们先来看一个例子：

假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如：

x=50，y=50

x=37.13,y=169.35

x="东经100度"，y="北纬100度"

针对不同的数据类型，除了借助方法重载，还可以借助自动封装和向上转型。我们知道，基本数据类型可以自动装箱，被转换成对应的包装类；Object是所有类的父类，任何一个类的实例都可以向上转型为Object类型。

程序清单：

1.public class DemoTest{

2.public static void main(String[]args){

3.Position p=new Position();

4.p.setX(50);//int->Integer->Object

5.p.setY(50);

6.int x=(Integer)p.getX();//向下转型

7.int y=(Integer)p.getY();

8.System.out.println("This Position is："+x+","+y);

9.p.setX(37.13);//double->Double->Object

10.p.setY("东经100度");

11.double m=(Double)p.getX();//必须向下转型

12.double n=(Double)p.getY();//运行期间抛出异常

13.System.out.println("This Position is："+m+","+n);

14.}

15.}

16.class Position{

17.Object x=0;

18.Object y=0;

19.//由于篇幅原因，这里省去setter和getter方法，请读者实验时自行加上

20.}

程序说明：上面的代码中，生成坐标时不会有任何问题，但是取出坐标时，要向下转型，但是向下转型存在着风险，而且编译期间不容易发现，只有在运行期间才会抛出异常，所以要尽量避免使用向下转型。运行上面的代码，第12行会抛出https://www.wendangku.net/doc/0b10376729.html,ng.ClassCastException 异常。那么，有没有更好的办法，既可以不使用重载（有重复代码），又能把风险降到最低呢？有，可以使用泛型类，它可以接受任意类型的数据。所谓“泛型”，就是“宽泛的数据类型”，任意的数据类型。

泛型（Generic type或者generics）是对Java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。可以在集合框架（Collection framework）中看到泛型的动机。

Java语言中引入泛型是一个较大的功能增强﹐不仅语言、类型系统和编译器有了较大

的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：

1.类型安全。泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

2.类型约束。Java程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作ClassCastException被抛出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。

3．消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

7.*.1泛型类与泛型接口

1.泛型类

在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用“,”号分隔。定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，就像使用普通的类型一样。

我们更改上面的代码，使用泛型类：

程序清单：

1.public class DemoTest{

2.public static void main(String[]args){

3.//实例化泛型类

4.Positionp1=new Position();

5.p1.setX(50);

6.p1.setY(50);

7.int x=p1.getX();

8.int y=p1.getY();

9.System.out.println("This Position is："+x+","+y);

10.Positionp2=new Position();

11.p2.setX(37.13);

12.p2.setY("东经100度");

13.double m=p2.getX();

14.String n=p2.getY();

15.System.out.println("This Position is："+m+","+n);

16.}

17.}

18.//定义泛型类

19.class Position{

20.T1x;

21.T2y;

22.//由于篇幅原因，这里省去setter和getter方法，请读者实验室自行加上

23.}

This Position is：50,50

This Position is：37.13,东经100度

程序说明：与普通类的定义相比，上面的代码在类名后面多出了，T1,T2是自定义的标识符，也是参数，用来传递数据的类型，而不是数据的值，我们称之为类型参数。在泛型中，不但数据的值可以通过参数传递，数据的类型也可以通过参数传递。T1,T2只是数据类型的占位符，运行时会被替换为真正的数据类型。类型参数（泛型参数）由尖括号包围，多个参数由英文逗号分隔，如或。类型参数需要在类名后面给出。一旦给出了类型参数，就可以在类中使用了。类型参数必须是一个合法的标识符，习惯上使用单个大写字母，通常情况下，K表示键，V表示值，E表示异常或错误，T表示一般意义上的数据类型。

泛型类在实例化时必须指出具体的类型，也就是向类型参数传值，格式为：

className variable=new className();

也可以省略等号右边的数据类型，但是会产生警告，即：

className variable=new className();

因为在使用泛型类时指明了数据类型，赋给其他类型的值会抛出异常，既不需要向下转型，也没有潜在的风险，比自动封装和向上转型要更加实用。

注意：

1、泛型是Java1.5的新增特性，它以C++模板为参照，本质是参数化类型(Parameterized Type)的应用。

2、类型参数只能用来表示引用类型，不能用来表示基本类型，如int、double、char等。但是传递基本类型不会报错，因为它们会自动封装成对应的包装类。

2.泛型接口

在Java中也可以定义泛型接口，这里不再赘述，仅仅给出示例代码：

程序清单：

1.public class DemoTest{

2.public static void main(String arsg[]){

https://www.wendangku.net/doc/0b10376729.html,obj=new InfoImp("https://www.wendangku.net/doc/0b10376729.html,");

4.System.out.println("Length Of String:"+obj.getVar().length());

5.}

6.}

7.//定义泛型接口

8.interface Info{

9.public T getVar();

10.}

11.//实现接口

12.class InfoImpimplements Info{

13.private T var;

14.//定义泛型构造方法

15.public InfoImp(T var){

16.this.setVar(var);

17.}//由于篇幅原因，省去了setter和getter方法，请读者加上

18.}

Length Of String:18

7.*.2泛型方法

1.泛型方法的使用

除了定义泛型类，还可以定义泛型方法，在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内，指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用“,”号分隔。定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。

例如，定义一个打印坐标的泛型方法。

程序清单：

1.public class DemoTest{

2.public static void main(String[]args){

3.//实例化泛型类

4.Positionp1=new Position();

5.p1.setX(52);

6.p1.setY(50);

7.p1.printPosition(p1.getX(),p1.getY());

8.Positionp2=new Position();

9.p2.setX(37.13);

10.p2.setY("东经100度");

11.p2.printPosition(p2.getX(),p2.getY());

12.}

13.}

14.//定义泛型类

15.class Position{

16.T1x;

17.T2y;//由于篇幅原因，省去了setter和getter方法，请读者加上

18.//定义泛型方法

19.publicvoid printPosition(T1x,T2y){

20.T1m=x;

21.T2n=y;

22.System.out.println("This Position is："+m+","+n);

23.}

24.}

输出结果：

This Position is：50,50

This Position is：37.13,东经100度

程序说明：上面的代码中定义了一个泛型方法printPosition()，既有普通参数，也有类型参数，类型参数需要放在修饰符后面、返回值类型前面。一旦定义了类型参数，就可以在参数列表、方法体和返回值类型中使用了。与使用泛型类不同，使用泛型方法时不必指明参数类型，编译器会根据传递的参数自动查找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。

注意：泛型方法与泛型类没有必然的联系，泛型方法有自己的类型参数，在普通类中也

可以定义泛型方法。泛型方法printPosition()中的类型参数T1,T2与泛型类Position中的T1,T2没有必然的联系，也可以使用其他的标识符代替：

1.public staticvoid printPosition(V1x,V2y){

2.V1m=x;

3.V2n=y;

4.System.out.println("This Position is："+m+","+n);

5.}

2、限制泛型

在上面的代码中，类型参数可以接受任意的数据类型，只要它是被定义过的。但是，很多时候我们只需要一部分数据类型就够了，用户传递其他数据类型可能会引起错误。例如，编写一个泛型函数用于返回不同类型数组（Integer数组、Double数组、Character数组等）中的最大值。

程序清单：

1.publicT getMax(T array[]){

2.T max=null;

3.for(T element:array){

4.max=element.doubleValue()>max.doubleValue()?element:max;

5.}

6.return max;

7.}

程序说明：这段代码会报错，因为doubleValue()是Number类的方法，不是所有的类都有该方法，所以我们要限制类型参数T，让它只能接受Number及其子类（Integer、Double、Character等）。通过extends关键字可以限制泛型的类型，改进上面的代码：程序清单：

1.publicT getMax(T array[]){

2.T max=null;

3.for(T element:array){

4.max=element.doubleValue()>max.doubleValue()?element:max;

5.}

6.return max;

7.}

程序说明：表示T只接受Number及其子类，传入其他类型的数据会报错。这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends 已经不是继承的含义了，应该理解为T是继承自Number类的类型，或者T是实现了某些接口的类型。

虽然Java泛型简单的用extends统一的表示了原有的extends和implements的概念，但仍要遵循应用的体系，Java只能继承一个类，但可以实现多个接口，所以你的某个类型需要用extends限定，且有多种类型的时候，只能存在一个是类，并且类写在第一位，接口列在后面，也就是：

这里的例子仅演示了泛型方法的类型限定，对于泛型类中类型参数的限制用完全一样的规则，只是加在类声明的头部，如：

1.public class DemoTest{

2.//T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了

3.}

7.*.3泛型擦除与泛型数组

1、泛型擦除

考虑如下代码的输出。

程序清单：

1.public class DemoTest{

2.public static void main(String[]args){

3.Class c1=new ArrayList().getClass();

4.Class c2=new ArrayList().getClass();

5.System.out.println(c1==c2);

6.}

7.}

程序说明：输出结果很神奇的显示:true。这是为什么呢？

为了解释清楚原因，在此不得不补充一个程序。

程序清单：

1.public class DemoTest{

2.public static void main(String[]args){

3.Listc1=new ArrayList();

4.Listc2=new ArrayList();

5.System.out.println(Arrays.toString(c1.getClass().getTypeParameters()));

6.System.out.println(Arrays.toString(c2.getClass().getTypeParameters()));

7.}

8.}

输出结果：

[E]

[E]

程序说明：根据JDK文档的描述，第5、6行Class.getTypeParameters()将返回一个TypeVariable对象的数组，表示有泛型所声明的类型参数。但是，正如从输出中所看到的，能够发现的只是用作参数占位符的标示符，而这不是有用的信息。因此残酷的现实是：在泛型代码的内部，无法获得任何有关泛型参数类型的信息。

因此，可以知道诸如类型参数标示符和泛型类型边界这类信息，但却无法知道用来创建某个特定实例的实际的类型参数。Java中的泛型是使用擦除来实现的，所以在使用泛型的时候，任何具体的类型信息都被擦除了，你唯一知道的就是知道当前使用的是一个对象。因此List和List在运行时事实上是相同的类型。这两种形式都被擦除成为他们的“原生”类型，即List。

泛型是JDK1.5才出现的，所以为了兼容，采用了擦除的方式实现。泛型类型只有在静态类型检查期间才出现，在此之后，程序中所有泛型类型都被擦除，替换为他们的非泛型上界。例如List将被擦除为List，而普通的类型变量在未指定边界的情况下将被擦除为Object

类型。

2、泛型数组

如上文所示，擦除丢失了在泛型代码中执行某些操作的能力。任何在运行时需要知道确切类型信息的操作都将无法工作。

程序清单：

1.class DemoTest{

2.private static final int SIZE=100;

3.public static void f(Object arg){

4.T var=new T();//编译错误

5.T[]array=new T[SIZE];//编译错误

6.T[]array=(T)new Object[SIZE];//编译错误

7.}

8.}

程序说明：在这段程序中，第4、5、6行均不能编译通过，可见不能直接创建真正意义上的泛型数组（之所以这么说是因为Java可以声明一个泛型数组，但是却永远不能真正创建一个泛型数组类型的对象）。

7.*.4通配符

在本节的前面的部分里已经说过了泛型类型的子类型的不相关性。即Apple是Fruit的子类，然而List却不是List的子类。但有些时候，我们希望能够像使用普通类型那样使用泛型类型：

向上转型一个泛型对象

向下转型一个泛型对象

由于泛型子类型的不相关性，原本有继承关系的对象不能像普通的类型那样向上转型。例如：

程序清单：

1.Listapples0=new ArrayList();

2.Listfruits0=new ArrayList();

3.fruits0=apples0;//无法赋值

4.apples0=fruits0;//无法赋值

5.apples0=(List)fruits0;//无法赋值

6.fruits0=(List)apples0;//无法赋值

程序说明：如程序第3-6行代码所示，无法将持有Apple的list对象赋值给持有Fruit

的list的引用，即无法向上转型；也无法将持有Fruit对象的List对象赋值给持有Apple对象的List引用；即使是进行强制类型转换也无法进行向上或者向下转型。

1、无界通配符“？”

为了使泛型的子类型仍然具有相关性，也即是在使用了泛型后依然能够保证继承关系，我们可以使用通配符“?”达到目的。

程序清单：

1.Listapples3=new ArrayList();

2.Listfruits3=new ArrayList();

3.Listcats=new ArrayList(){};

4.fruits3=apples3;

5.apples3=fruits3;

6.cats=fruits3;//

7.fruits3.add(new Apple());//无法赋值

8.apples3.add(new Apple());//无法赋值

程序说明：使用了通配符之后，就可以实现向上转型或向下转型了，也即可以将持有Apple的List对象赋值给持有Fruit的List引用了，反之也可行。然而第6行代码显示，因为使用了通配符，甚至可以将一个持有Fruit的List对象赋值给一个持有Cat的List引用。Fruit 与Cat显然并没有继承关系，那么为什么会出现这种我们不期待的情况呢？原来是因为List在功能上等价于List，这意味着编译器在运行中会将泛型擦出到Object上界，也即List能够接受某种特定类型的List，这个类型只要是Object 类型本身或Object子类就可以。既然如此，编译器就不会检查List中容纳的到底是什么类型的对象了。

从代码中可以看出，由List声明的List可以容纳任意某种特定的类型的List对象。因此给List初始化之后就不能够再往里添加任何类型的对象了，哪怕是Object的对象也不可以，但是可以添加null。同时，这也是List与List