深入理解java泛型详解_深入理解java泛型

一、 什么是泛型？

泛

型(Generic type 或者 generics)是对

简单的理解，就是对类型的参数化，比如我们定义一个类属性或者实例属性时，往往要指定具体的类型，如Integer、Person等等，

但是如果使用了泛型，我们把这些具体的类型参数化，用一个广泛的可以表示所有类型的“类型”T来定义，那这个T就是泛型的表示。

可以在集合框架(Collection framework)中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String)的对象。

因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();

m.put("key", "value");

String s = (String) m.get("key");

要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。如果map中保存了的不是 String 的数据，则上面的代码将会抛出 ClassCastException。

二、 泛型的好处

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：

1、 类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。

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

3、 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换(没有泛型的话，程序员会指定这些强制类型转换)插入生成的字节码中。

三、 泛型用法的例子

3.1  我们再程序中定义一个类，并制定泛型参数

class Point{       // 此处可以随便写标识符号，T是type的简称

private T var ; // var的类型由T指定，即：由外部指定

public T getVar(){  // 返回值的类型由外部决定

return var ;

}

public void setVar(T var){  // 设置的类型也由外部决定

this.var = var ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Point p = new Point() ; // 里面的var类型为String类型

p.setVar("MLDN") ;      // 设置字符串

System.out.println(p.getVar().length()) ;   // 取得字符串的长度

}

};

说明：

1. 命名类型参数

推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同(参阅 附录 A：与 C++ 模板的比较)，并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式，推荐的名称是：

K —— 键，比如映射的键。

V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。

E —— 异常类。

T —— 泛型。

2. 以上，是将var变量设置为了String类型，当然也可以设置为其他的数据类型，比如Integer等，如果你设置的内容与你制定的泛型类型不一致，则在编译时将出现错误。比如：

class Point{       // 此处可以随便写标识符号，T是type的简称

private T var ; // var的类型由T指定，即：由外部指定

public T getVar(){  // 返回值的类型由外部决定

return var ;

}

public void setVar(T var){  // 设置的类型也由外部决定

this.var = var ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Point p = new Point() ;   // 里面的var类型为String类型

p.setVar("MLDN") ;      // 设置字符串

}

};

程序在编译期就出报错：

GenericsDemo.java:13: 错误: 无法将类 Point中的方法 setVar应用到给定类型;

p.setVar("MLDN") ;      // 设置字符串

^

需要: Integer

找到: String

原因: 无法通过方法调用转换将实际参数String转换为Integer

其中, T是类型变量:

T扩展已在类 Point中声明的Object

1 个错误

看log就可以发现，我我们已经规定了泛型的类型为Integer，则说明T类型就是Integer，所以在传入参数时，当然不能传入String类型的参数了。

3.2  构造方法中使用泛型

构造方法可以为类中的属性进行初始化，如果类中的属性用过泛型指定，而又需要通过构造器设置属性的内容时，那么构造方法的定义与之前并无不同，不需要像声明类那样指定泛型。

class Point{       // 此处可以随便写标识符号，T是type的简称

private T var ; // var的类型由T指定，即：由外部指定

public Point(T var){        // 通过构造方法设置内容

this.var = var ;

}

public T getVar(){  // 返回值的类型由外部决定

return var ;

}

public void setVar(T var){  // 设置的类型也由外部决定

this.var = var ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Point p = new Point("MLDN") ;   // 里面的var类型为String类型

System.out.println("内容：" + p.getVar()) ;

}

};

这里我们讲一个泛型的警告问题： 当你为某个类只定了泛型，但是，你实例化该类的对象的时候，并没有指定泛型的类型，则程序在编译时会出现警告，警告并不会影响程序的运行。

class Info{

private T var ;

public T getVar(){

return this.var ;

}

public void setVar(T var){

this.var = var ;

}

public String toString(){       // 覆写Object类中的toString()方法

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i = new Info() ;       // 警告，没有指定泛型类型

i.setVar("MLDN") ;          // 设置字符串

System.out.println("内容：" + i.getVar()) ;

}

};

编译程序会出现警告：

注: GenericsDemo10.java使用了未经检查或不安全的操作。

注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

说明： 由于没有指定泛型类型，则类可以接受任何数据类型，也就是此时的var的类型就是Object，所有的泛型信息都会被擦除。

三、 泛型通配符

3.1 引入泛型通配符

我们先来看一个例子：

class Info{

private T var ;     // 定义泛型变量

public void setVar(T var){

this.var = var ;

}

public T getVar(){

return this.var ;

}

public String toString(){   // 直接打印

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i = new Info() ;       // 使用String为泛型类型

i.setVar("MLDN") ;                          // 设置内容

fun(i) ;

}

public static void fun(Info temp){        // 接收Object泛型类型的Info对象

System.out.println("内容：" + temp) ;

}

};

在方法调用过程中，我们将Info传递给Info，此时会发现，程序在编译时会报错：

GenericsDemo.java:17: 错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;

fun(i) ;

^

需要: Info

找到: Info

原因: 无法通过方法调用转换将实际参数Info转换为Info

1 个错误

上述错误说明，泛型对象进行引用传递的时候，类型必须一致，Info并不是Info的父类。如果现在非要传递，则可以讲fun方法中的info参数的泛型取消掉：

public static void main(String args[]){

Info i = new Info() ;       // 使用String为泛型类型

i.setVar("MLDN") ;                          // 设置内容

fun(i) ;

}

public static void fun(Info temp){      // 接收Object泛型类型的Info对象

System.out.println("内容：" + temp) ;

}

当然，这样看来程序已经可以正常运行了，但是，我们之前已经指定了泛型，此时却在方法传递过程中把它取消了，总是不妥的，所以，java提供了？通配符来匹配任何的泛型类型。

public class GenericsDemo{

public static void main(String args[]){

Info i = new Info() ;       // 使用String为泛型类型

i.setVar("MLDN") ;                          // 设置内容

fun(i) ;

}

public static void fun(Info> temp){     // 可以接收任意的泛型对象

System.out.println("内容：" + temp) ;

}

};

我们应当注意，在fun方法中，我们是直接输出了temp对象，并为其做任何修改，实质上，使用？可以接收任意的内容，但是此内容却无法直接使用>进行修改，比如：我们这样去创建一个对象：

public class GenericsDemo{

public static void main(String args[]){

Info> i = new Info() ;        // 使用String为泛型类型

i.setVar("MLDN") ;                          // 设置内容

}

};

编译后，程序会报错：

GenericsDemo.java:16: 错误: 无法将类 Info中的方法 setVar应用到给定类型;

i.setVar("MLDN") ;                          // 设置内容

^

需要: CAP#1

找到: String

原因: 无法通过方法调用转换将实际参数String转换为CAP#1

其中, T是类型变量:

T扩展已在类 Info中声明的Object

其中, CAP#1是新类型变量:

CAP#1从?的捕获扩展Object

1 个错误

四、 受限泛型

4.1 泛型上限： 表示参数化的类型可能是所指定类型，或者是其子类。

class Info{

private T var ;     // 定义泛型变量

public void setVar(T var){

this.var = var ;

}

public T getVar(){

return this.var ;

}

public String toString(){   // 直接打印

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i1 = new Info() ; // 声明Integer的泛型对象

Info i2 = new Info() ;  // 声明Float的泛型对象

i1.setVar(30) ;  // 设置整数，自动装箱

i2.setVar(30.1f) ;  // 设置小数，自动装箱

fun(i1) ;

fun(i2) ;

}

public static void fun(Info extends Number> temp){  // 只能接收Number及其Number的子类

System.out.print(temp + "、") ;

}

};

如果你接收的不是Number类及其子类，则程序会报错：

public class GenericsDemo{

public static void main(String args[]){

Info i1 = new Info() ;      // 声明String的泛型对象

i1.setVar("hello") ;

fun(i1) ;

}

public static void fun(Info extends Number> temp){  // 只能接收Number及其Number的子类

System.out.print(temp + "、") ;

}

};

错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;

fun(i1) ;

^

需要: Info extends Number>

找到: Info

原因: 无法通过方法调用转换将实际参数Info转换为Info extends Number>

1 个错误

4.2 泛型下限：使用的泛型只能是本类及其父类类型上应用的时候，就必须使用泛型的下限。

class Info{

private T var ;     // 定义泛型变量

public void setVar(T var){

this.var = var ;

}

public T getVar(){

return this.var ;

}

public String toString(){   // 直接打印

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i1 = new Info() ;      // 声明String的泛型对象

Info i2 = new Info() ;      // 声明Object的泛型对象

i1.setVar("hello") ;

i2.setVar(new Object()) ;

fun(i1) ;

fun(i2) ;

}

public static void fun(Info super String> temp){    // 只能接收String或Object类型的泛型

System.out.print(temp + "、") ;

}

};

五、 泛型与子类继承

一个类的子类可以通过对象多态性，为其父类实例化，但是在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接受的，例如，Info不能使用 Info接收。

六、 泛型接口

6.1 定义泛型接口

interface Info{   // 在接口上定义泛型

public T getVar() ;  // 定义抽象方法，抽象方法的返回值就是泛型类型

}

6.2 泛型接口的两种实现方式

6.2.1 定义子类，在子类的上也使用泛型声明

interface Info{        // 在接口上定义泛型

public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型

}

class InfoImpl implements Info{   // 定义泛型接口的子类

private T var ;             // 定义属性

public InfoImpl(T var){     // 通过构造方法设置属性内容

this.setVar(var) ;

}

public void setVar(T var){

this.var = var ;

}

public T getVar(){

return this.var ;

}

};

public class GenericsDemo{

public static void main(String arsg[]){

Info i = null;        // 声明接口对象

i = new InfoImpl("李兴华") ; // 通过子类实例化对象

System.out.println("内容：" + i.getVar()) ;

}

};

6.2.2 定义子类，直接指定泛型的具体操作类型

interface Info{        // 在接口上定义泛型

public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型

}

class InfoImpl implements Info{   // 定义泛型接口的子类

private String var ;                // 定义属性

public InfoImpl(String var){        // 通过构造方法设置属性内容

this.setVar(var) ;

}

public void setVar(String var){

this.var = var ;

}

public String getVar(){

return this.var ;

}

};

public class GenericsDemo{

public static void main(String arsg[]){

Info i = null;      // 声明接口对象

i = new InfoImpl("李兴华") ;   // 通过子类实例化对象

System.out.println("内容：" + i.getVar()) ;

}

};

七、 泛型方法

7.1 泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

class Demo{

public  T fun(T t){            // 可以接收任意类型的数据

return t ;          // 直接把参数返回

}

};

public class GenericsDemo{

public static void main(String args[]){

Demo d = new Demo() ;   // 实例化Demo对象

String str = d.fun("李兴华") ;  // 传递字符串

int i = d.fun(30) ;     // 传递数字，自动装箱

System.out.println(str) ;   // 输出内容

System.out.println(i) ;     // 输出内容

}

};

7.2 通过泛型方法，返回泛型类的实例

class Info{ // 指定上限，只能是数字类型

private T var ;     // 此类型由外部决定

public T getVar(){

return this.var ;

}

public void setVar(T var){

this.var = var ;

}

public String toString(){       // 覆写Object类中的toString()方法

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i = fun(30) ;

System.out.println(i.getVar()) ;

}

public static  Info fun(T param){

Info temp = new Info() ;      // 根据传入的数据类型实例化Info

temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中

return temp ;   // 返回实例化对象

}

};

7.2 使用泛型，统一传递参数的类型

class Info{    // 指定上限，只能是数字类型

private T var ;     // 此类型由外部决定

public T getVar(){

return this.var ;

}

public void setVar(T var){

this.var = var ;

}

public String toString(){       // 覆写Object类中的toString()方法

return this.var.toString() ;

}

};

public class GenericsDemo{

public static void main(String args[]){

Info i1 = new Info() ;

Info i2 = new Info() ;

i1.setVar("HELLO") ;        // 设置内容

i2.setVar("李兴华") ;      // 设置内容

add(i1,i2) ;

}

public static  void add(Info i1,Info i2){

System.out.println(i1.getVar() + " " + i2.getVar()) ;

}

};

对于上述程序，我们再add方法里指定的T类型必须一致，比如上面指定了两个String类型，如果你传递的不一致，则会出现错误。

public class GenericsDemo{

public static void main(String args[]){

Info i1 = new Info() ;

Info i2 = new Info() ;

i1.setVar(30) ;     // 设置内容

i2.setVar("李兴华") ;      // 设置内容

add(i1,i2) ;

}

public static  void add(Info i1,Info i2){

System.out.println(i1.getVar() + " " + i2.getVar()) ;

}

};

编译时报错：

GenericsDemo.java:19: 错误: 无法将类 GenericsDemo中的方法 add应用到给定类型;

add(i1,i2) ;

^

需要: Info,Info

找到: Info,Info

原因: 不存在类型变量T的实例, 以使参数类型Info与形式参数类型Info一致

其中, T是类型变量:

T扩展已在方法 add(Info,Info)中声明的Object

1 个错误

六、 泛型数组

不能创建一个确切泛型类型的数组。如下面代码会出错。

List[] lsa = new ArrayList[10];

因为如果可以这样，那么考虑如下代码，会导致运行时错误。

List[] lsa = new ArrayList[10]; // 实际上并不允许这样创建数组

Object o = lsa;

Object[] oa = (Object[]) o;

Listli = new ArrayList();

li.add(new Integer(3));

oa[1] = li;// unsound, but passes run time store check

String s = lsa[1].get(0); //run-time error - ClassCastException

因此只能创建带通配符的泛型数组，如下面例子所示，这回可以通过编译，但是在倒数第二行代码

中必须显式的转型才行，即便如此，最后还是会抛出类型转换异常，因为存储在lsa中的是List类型的对象，而不是

List类型。最后一行代码是正确的，类型匹配，不会抛出异常。

List>[] lsa = new List>[10]; // ok, array of unbounded wildcard type

Object o = lsa;

Object[] oa = (Object[]) o;

Listli = new ArrayList();

li.add(new Integer(3));

oa[1] = li; //correct

String s = (String) lsa[1].get(0);// run time error, but cast is explicit

Integer it = (Integer)lsa[1].get(0); // OK