深入理解java泛型

时间:2022-08-12 19:25:50


一、 什么是泛型?

泛型(Generic type 或者 generics)是对 简单的理解,就是对类型的参数化,比如我们定义一个类属性或者实例属性时,往往要指定具体的类型,如Integer、Person等等, 但是如果使用了泛型,我们把这些具体的类型参数化,用一个广泛的可以表示所有类型的“类型”T来定义,那这个T就是泛型的表示。

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

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

[java] view plain copy print?
  1. Map m = new HashMap();  
  2. m.put("key", "value");  
  3. String s = (String) m.get("key");  
要让程序通过编译,必须将 get() 的结果强制类型转换为 String,并且希望结果真的是一个 String。如果map中保存了的不是 String 的数据,则上面的代码将会抛出 ClassCastException。


二、 泛型的好处

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化,以支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。这带来了很多好处:
1、 类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。
2、 消除强制类型转换。 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。

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


三、 泛型用法的例子

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

 

[java] view plain copy print?
  1. class Point<T>{       // 此处可以随便写标识符号,T是type的简称  
  2.     private T var ; // var的类型由T指定,即:由外部指定  
  3.     public T getVar(){  // 返回值的类型由外部决定  
  4.         return var ;  
  5.     }  
  6.     public void setVar(T var){  // 设置的类型也由外部决定  
  7.         this.var = var ;  
  8.     }  
  9. };  
  10. public class GenericsDemo{  
  11.     public static void main(String args[]){  
  12.         Point<String> p = new Point<String>() ; // 里面的var类型为String类型  
  13.         p.setVar("MLDN") ;      // 设置字符串  
  14.         System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
  15.     }  
  16. };  

说明: 

1. 命名类型参数
推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同(参阅 附录 A:与 C++ 模板的比较),并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式,推荐的名称是:
K —— 键,比如映射的键。 
V —— 值,比如 List 和 Set 的内容,或者 Map 中的值。 
E —— 异常类。 
T —— 泛型。

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

 

[java] view plain copy print?
  1. class Point<T>{       // 此处可以随便写标识符号,T是type的简称  
  2.     private T var ; // var的类型由T指定,即:由外部指定  
  3.     public T getVar(){  // 返回值的类型由外部决定  
  4.         return var ;  
  5.     }  
  6.     public void setVar(T var){  // 设置的类型也由外部决定  
  7.         this.var = var ;  
  8.     }  
  9. };  
  10. public class GenericsDemo{  
  11.     public static void main(String args[]){  
  12.         Point<Integer> p = new Point<Integer>() ;   // 里面的var类型为String类型  
  13.         p.setVar("MLDN") ;      // 设置字符串  
  14.     }  
  15. };  
程序在编译期就出报错:

 

[plain] view plain copy print?
  1. GenericsDemo.java:13: 错误: 无法将类 Point<T>中的方法 setVar应用到给定类型;  
  2.         p.setVar("MLDN") ;      // 设置字符串  
  3.          ^  
  4.   需要: Integer  
  5.   找到: String  
  6.   原因: 无法通过方法调用转换将实际参数String转换为Integer  
  7.   其中, T是类型变量:  
  8.     T扩展已在类 Point中声明的Object  
  9. 1 个错误  


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


 3.2  构造方法中使用泛型

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

[java] view plain copy print?
  1. class Point<T>{       // 此处可以随便写标识符号,T是type的简称  
  2.     private T var ; // var的类型由T指定,即:由外部指定  
  3.     public Point(T var){        // 通过构造方法设置内容  
  4.         this.var = var ;  
  5.     }  
  6.     public T getVar(){  // 返回值的类型由外部决定  
  7.         return var ;  
  8.     }  
  9.     public void setVar(T var){  // 设置的类型也由外部决定  
  10.         this.var = var ;  
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Point<String> p = new Point<String>("MLDN") ;   // 里面的var类型为String类型  
  16.         System.out.println("内容:" + p.getVar()) ;  
  17.     }  
  18. };  

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

 

[java] view plain copy print?
  1. class Info<T>{  
  2.     private T var ;  
  3.     public T getVar(){  
  4.         return this.var ;  
  5.     }  
  6.     public void setVar(T var){  
  7.         this.var = var ;  
  8.     }  
  9.     public String toString(){       // 覆写Object类中的toString()方法  
  10.         return this.var.toString() ;  
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info i = new Info() ;       // 警告,没有指定泛型类型  
  16.         i.setVar("MLDN") ;          // 设置字符串  
  17.         System.out.println("内容:" + i.getVar()) ;  
  18.     }  
  19. };  
编译程序会出现警告:
注: GenericsDemo10.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

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


三、 泛型通配符

3.1 引入泛型通配符

我们先来看一个例子:

 

[java] view plain copy print?
  1. class Info<T>{  
  2.     private T var ;     // 定义泛型变量  
  3.     public void setVar(T var){  
  4.         this.var = var ;  
  5.     }  
  6.     public T getVar(){  
  7.         return this.var ;  
  8.     }  
  9.     public String toString(){   // 直接打印  
  10.         return this.var.toString() ;  
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
  16.         i.setVar("MLDN") ;                          // 设置内容  
  17.         fun(i) ;  
  18.     }  
  19.     public static void fun(Info<Object> temp){        // 接收Object泛型类型的Info对象  
  20.         System.out.println("内容:" + temp) ;  
  21.     }  
  22. };  
在方法调用过程中,我们将Info<String>传递给Info<Object>,此时会发现,程序在编译时会报错:

 

[sql] view plain copy print?
  1. GenericsDemo.java:17: 错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;  
  2.         fun(i) ;  
  3.         ^  
  4.   需要: Info<Object>  
  5.   找到: Info<String>  
  6.   原因: 无法通过方法调用转换将实际参数Info<String>转换为Info<Object>  
  7. 1 个错误</span>  


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

 

[java] view plain copy print?
  1. public static void main(String args[]){  
  2.     Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
  3.     i.setVar("MLDN") ;                          // 设置内容  
  4.     fun(i) ;  
  5. }  
  6. public static void fun(Info temp){      // 接收Object泛型类型的Info对象  
  7.     System.out.println("内容:" + temp) ;  
  8. }  

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

 

[java] view plain copy print?
  1. public class GenericsDemo{  
  2.     public static void main(String args[]){  
  3.         Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
  4.         i.setVar("MLDN") ;                          // 设置内容  
  5.         fun(i) ;  
  6.     }  
  7.     public static void fun(Info<?> temp){     // 可以接收任意的泛型对象  
  8.         System.out.println("内容:" + temp) ;  
  9.     }  
  10. };  
我们应当注意,在fun方法中,我们是直接输出了temp对象,并为其做任何修改,实质上,使用?可以接收任意的内容,但是此内容却无法直接使用<?>进行修改,比如:我们这样去创建一个对象:

 

[java] view plain copy print?
  1. public class GenericsDemo{  
  2.     public static void main(String args[]){  
  3.         Info<?> i = new Info<String>() ;        // 使用String为泛型类型  
  4.         i.setVar("MLDN") ;                          // 设置内容  
  5.     }  
  6. };  
编译后,程序会报错:

 

[plain] view plain copy print?
  1. GenericsDemo.java:16: 错误: 无法将类 Info<T>中的方法 setVar应用到给定类型;  
  2.         i.setVar("MLDN") ;                          // 设置内容  
  3.          ^  
  4.   需要: CAP#1  
  5.   找到: String  
  6.   原因: 无法通过方法调用转换将实际参数String转换为CAP#1  
  7.   其中, T是类型变量:  
  8.     T扩展已在类 Info中声明的Object  
  9.   其中, CAP#1是新类型变量:  
  10.     CAP#1从?的捕获扩展Object  
  11. 1 个错误  


四、 受限泛型

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

 

[java] view plain copy print?
  1. class Info<T>{  
  2.     private T var ;     // 定义泛型变量  
  3.     public void setVar(T var){  
  4.         this.var = var ;  
  5.     }  
  6.     public T getVar(){  
  7.         return this.var ;  
  8.     }  
  9.     public String toString(){   // 直接打印  
  10.         return this.var.toString() ;  
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info<Integer> i1 = new Info<Integer>() ; // 声明Integer的泛型对象  
  16.         Info<Float> i2 = new Info<Float>() ;  // 声明Float的泛型对象  
  17.         i1.setVar(30) ;  // 设置整数,自动装箱  
  18.         i2.setVar(30.1f) ;  // 设置小数,自动装箱  
  19.         fun(i1) ;  
  20.         fun(i2) ;  
  21.     }  
  22.     public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类  
  23.         System.out.print(temp + "、") ;  
  24.     }  
  25. };  


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

 

[java] view plain copy print?
  1. public class GenericsDemo{  
  2.     public static void main(String args[]){  
  3.         Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象  
  4.         i1.setVar("hello") ;  
  5.         fun(i1) ;  
  6.     }  
  7.     public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类  
  8.         System.out.print(temp + "、") ;  
  9.     }  
  10. };  
错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;
fun(i1) ;
^
  需要: Info<? extends Number>
  找到: Info<String>
  原因: 无法通过方法调用转换将实际参数Info<String>转换为Info<? extends Number>
1 个错误


4.2 泛型下限:使用的泛型只能是本类及其父类类型上应用的时候,就必须使用泛型的下限。
[java] view plain copy print?
  1. class Info<T>{  
  2.     private T var ;     // 定义泛型变量  
  3.     public void setVar(T var){  
  4.         this.var = var ;  
  5.     }  
  6.     public T getVar(){  
  7.         return this.var ;  
  8.     }  
  9.     public String toString(){   // 直接打印  
  10.         return this.var.toString() ;  
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象  
  16.         Info<Object> i2 = new Info<Object>() ;      // 声明Object的泛型对象  
  17.         i1.setVar("hello") ;  
  18.         i2.setVar(new Object()) ;  
  19.         fun(i1) ;  
  20.         fun(i2) ;  
  21.     }  
  22.     public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型  
  23.         System.out.print(temp + "、") ;  
  24.     }  
  25. };  


五、 泛型与子类继承

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


六、 泛型接口

6.1 定义泛型接口

 

[java] view plain copy print?
  1. interface Info<T>{   // 在接口上定义泛型  
  2.    public T getVar() ;  // 定义抽象方法,抽象方法的返回值就是泛型类型  
  3. }  


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

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

 

[java] view plain copy print?
  1. interface Info<T>{        // 在接口上定义泛型  
  2.     public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型  
  3. }  
  4. class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
  5.     private T var ;             // 定义属性  
  6.     public InfoImpl(T var){     // 通过构造方法设置属性内容  
  7.         this.setVar(var) ;    
  8.     }  
  9.     public void setVar(T var){  
  10.         this.var = var ;  
  11.     }  
  12.     public T getVar(){  
  13.         return this.var ;  
  14.     }  
  15. };  
  16. public class GenericsDemo{  
  17.     public static void main(String arsg[]){  
  18.         Info<String> i = null;        // 声明接口对象  
  19.         i = new InfoImpl<String>("李兴华") ; // 通过子类实例化对象  
  20.         System.out.println("内容:" + i.getVar()) ;  
  21.     }  
  22. };  

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

 

[java] view plain copy print?
  1. interface Info<T>{        // 在接口上定义泛型  
  2.     public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型  
  3. }  
  4. class InfoImpl implements Info<String>{   // 定义泛型接口的子类  
  5.     private String var ;                // 定义属性  
  6.     public InfoImpl(String var){        // 通过构造方法设置属性内容  
  7.         this.setVar(var) ;    
  8.     }  
  9.     public void setVar(String var){  
  10.         this.var = var ;  
  11.     }  
  12.     public String getVar(){  
  13.         return this.var ;  
  14.     }  
  15. };  
  16. public class GenericsDemo{  
  17.     public static void main(String arsg[]){  
  18.         Info i = null;      // 声明接口对象  
  19.         i = new InfoImpl("李兴华") ;   // 通过子类实例化对象  
  20.         System.out.println("内容:" + i.getVar()) ;  
  21.     }  
  22. };  


七、 泛型方法


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

[java] view plain copy print?
  1. class Demo{  
  2.     public <T> T fun(T t){            // 可以接收任意类型的数据  
  3.         return t ;          // 直接把参数返回  
  4.     }  
  5. };  
  6. public class GenericsDemo{  
  7.     public static void main(String args[]){  
  8.         Demo d = new Demo() ;   // 实例化Demo对象  
  9.         String str = d.fun("李兴华") ;  // 传递字符串  
  10.         int i = d.fun(30) ;     // 传递数字,自动装箱  
  11.         System.out.println(str) ;   // 输出内容  
  12.         System.out.println(i) ;     // 输出内容  
  13.     }  
  14. };  

7.2 通过泛型方法,返回泛型类的实例
[java] view plain copy print?
  1. class Info<T extends Number>{ // 指定上限,只能是数字类型  
  2.     private T var ;     // 此类型由外部决定  
  3.     public T getVar(){  
  4.         return this.var ;     
  5.     }  
  6.     public void setVar(T var){  
  7.         this.var = var ;  
  8.     }  
  9.     public String toString(){       // 覆写Object类中的toString()方法  
  10.         return this.var.toString() ;      
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info<Integer> i = fun(30) ;  
  16.         System.out.println(i.getVar()) ;  
  17.     }  
  18.     public static <T extends Number> Info<T> fun(T param){  
  19.         Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info  
  20.         temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中  
  21.         return temp ;   // 返回实例化对象  
  22.     }  
  23. };  

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

 

[java] view plain copy print?
  1. class Info<T>{    // 指定上限,只能是数字类型  
  2.     private T var ;     // 此类型由外部决定  
  3.     public T getVar(){  
  4.         return this.var ;     
  5.     }  
  6.     public void setVar(T var){  
  7.         this.var = var ;  
  8.     }  
  9.     public String toString(){       // 覆写Object类中的toString()方法  
  10.         return this.var.toString() ;      
  11.     }  
  12. };  
  13. public class GenericsDemo{  
  14.     public static void main(String args[]){  
  15.         Info<String> i1 = new Info<String>() ;  
  16.         Info<String> i2 = new Info<String>() ;  
  17.         i1.setVar("HELLO") ;        // 设置内容  
  18.         i2.setVar("李兴华") ;      // 设置内容  
  19.         add(i1,i2) ;  
  20.     }  
  21.     public static <T> void add(Info<T> i1,Info<T> i2){  
  22.         System.out.println(i1.getVar() + " " + i2.getVar()) ;  
  23.     }  
  24. };  


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

 

[java] view plain copy print?
  1. public class GenericsDemo{  
  2.     public static void main(String args[]){  
  3.         Info<Integer> i1 = new Info<Integer>() ;  
  4.         Info<String> i2 = new Info<String>() ;  
  5.         i1.setVar(30) ;     // 设置内容  
  6.         i2.setVar("李兴华") ;      // 设置内容  
  7.         add(i1,i2) ;  
  8.     }  
  9.     public static <T> void add(Info<T> i1,Info<T> i2){  
  10.         System.out.println(i1.getVar() + " " + i2.getVar()) ;  
  11.     }  
  12. };  

编译时报错:

 

[java] view plain copy print?
  1. GenericsDemo.java:19: 错误: 无法将类 GenericsDemo中的方法 add应用到给定类型;  
  2.         add(i1,i2) ;  
  3.         ^  
  4.   需要: Info<T>,Info<T>  
  5.   找到: Info<Integer>,Info<String>  
  6.   原因: 不存在类型变量T的实例, 以使参数类型Info<String>与形式参数类型Info<T>一致  
  7.   其中, T是类型变量:  
  8.     T扩展已在方法 <T>add(Info<T>,Info<T>)中声明的Object  
  9. 1 个错误  

六、 泛型数组

不能创建一个确切泛型类型的数组。如下面代码会出错。
List<String>[] lsa = new ArrayList<String>[10]; 
因为如果可以这样,那么考虑如下代码,会导致运行时错误。 

[java] view plain copy print?
  1. List<String>[] lsa = new ArrayList<String>[10]; // 实际上并不允许这样创建数组    
  2. Object o = lsa;    
  3. Object[] oa = (Object[]) o;    
  4. List<Integer>li = new ArrayList<Integer>();    
  5. li.add(new Integer(3));    
  6. oa[1] = li;// unsound, but passes run time store check    
  7. String s = lsa[1].get(0); //run-time error - ClassCastException  


因此只能创建带通配符的泛型数组,如下面例子所示,这回可以通过编译,但是在倒数第二行代码中必须显式的转型才行,即便如此,最后还是会抛出类型转换异常,因为存储在lsa中的是List<Integer>类型的对象,而不是List<String>类型。最后一行代码是正确的,类型匹配,不会抛出异常。
[java] view plain copy print?
  1. List<?>[] lsa = new List<?>[10]; // ok, array of unbounded wildcard type    
  2. Object o = lsa;    
  3. Object[] oa = (Object[]) o;    
  4. List<Integer>li = new ArrayList<Integer>();    
  5. li.add(new Integer(3));    
  6. oa[1] = li; //correct    
  7. String s = (String) lsa[1].get(0);// run time error, but cast is explicit    
  8. Integer it = (Integer)lsa[1].get(0); // OK