泛型

​ 

1. /*
2. *作者：呆萌老师
3. *☑csdn认证讲师
4. *☑51cto高级讲师
5. *☑腾讯课堂认证讲师
6. *☑网易云课堂认证讲师
7. *☑华为开发者学堂认证讲师
8. *☑爱奇艺千人名师计划成员
9. *在这里给大家分享技术、知识和生活
10. *各种干货，记得关注哦！
11. *vx：it_daimeng
12. */

复制代码

　　
1. 概述
泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。
 
什么是泛型？为什么要使用泛型？
 
泛型，即“参数化类型”。之前我们定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
 
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
 
2. 一个被举了无数次的例子：

1. List arrayList = new ArrayList();
3. arrayList.add("aaaa");
5. arrayList.add(100);
9. for(int i = 0; i< arrayList.size();i++){
11.     String item = (String)arrayList.get(i);
13.     Log.d("泛型测试","item = " + item);
15. }

复制代码

毫无疑问，程序的运行结果会以崩溃结束：
 
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
 
ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
 
我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。
 
List arrayList = new ArrayList();
...
//arrayList.add(100); 在编译阶段，编译器就会报错
 
3. 特性
泛型只在编译阶段有效。看下面的代码：

1. List<String> stringArrayList = new ArrayList<String>();
3. List<Integer> integerArrayList = new ArrayList<Integer>();
7. Class classStringArrayList = stringArrayList.getClass();
9. Class classIntegerArrayList = integerArrayList.getClass();
13. if(classStringArrayList.equals(classIntegerArrayList)){
15.     Log.d("泛型测试","类型相同");
17. }

复制代码

　　
输出结果：D/泛型测试: 类型相同。
 
通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。
 
对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。
 
4. 泛型的使用
泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法
 
4.3 泛型类
泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。
 
泛型类的最基本写法（这么看可能会有点晕，会在下面的例子中详解）：
 
class 类名称 {
  private 泛型标识 /*（成员变量类型）*/ var;
  .....
 
  }
}
一个最普通的泛型类：
 
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型

1. public class Generic<T>{
3.     //key这个成员变量的类型为T,T的类型由外部指定
5.     private T key;
9.     public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
11.         this.key = key;
13.     }
17.     public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
19.         return key;
21.     }
23. }

复制代码

　　

1. //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
3. //传入的实参类型需与泛型的类型参数类型相同，即为Integer.
5. Generic<Integer> genericInteger = new Generic<Integer>(123456);
9. //传入的实参类型需与泛型的类型参数类型相同，即为String.
11. Generic<String> genericString = new Generic<String>("key_vlaue");
13. Log.d("泛型测试","key is " + genericInteger.getKey());
15. Log.d("泛型测试","key is " + genericString.getKey());

复制代码

　　
泛型测试: key is 123456
泛型测试: key is key_vlaue
 
定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
 
看一个例子：

1. Generic generic = new Generic("111111");
3. Generic generic1 = new Generic(4444);
5. Generic generic2 = new Generic(55.55);
7. Generic generic3 = new Generic(false);
11. Log.d("泛型测试","key is " + generic.getKey());
13. Log.d("泛型测试","key is " + generic1.getKey());
15. Log.d("泛型测试","key is " + generic2.getKey());
17. Log.d("泛型测试","key is " + generic3.getKey());

复制代码

　　
泛型测试: key is 111111
泛型测试: key is 4444
泛型测试: key is 55.55
泛型测试: key is false
注意：
 
泛型的类型参数只能是类类型，不能是简单类型。
不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
 
if(ex_num instanceof Generic){  
}
4.4 泛型接口
泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：
 
//定义一个泛型接口
public interface Generator {
    public T next();
}
当实现泛型接口的类，未传入泛型实参时：
 
/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator implements Generator{
 * 如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错："Unknown class"
 */

1. class FruitGenerator<T> implements Generator<T>{
3.     @Override
5.     public T next() {
7.         return null;
9.     }
11. }

复制代码

当实现泛型接口的类，传入泛型实参时：
 
/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator，public T next();中的的T都要替换成传入的String类型。
 */

1. public class FruitGenerator implements Generator<String> {
5.     private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
9.     @Override
11.     public String next() {
13.         Random rand = new Random();
15.         return fruits[rand.nextInt(3)];
17.     }
19. }

复制代码

　　
4.5 泛型通配符
我们知道Ingeter是Number的一个子类，同时在特性章节中我们也验证过Generic与Generic实际上是相同的一种基本类型。那么问题来了，在使用Generic作为形参的方法中，能否使用Generic的实例传入呢？在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢？
 
为了弄清楚这个问题，我们使用Generic这个泛型类继续看下面的例子：

1. public void showKeyValue1(Generic<Number> obj){
3.     Log.d("泛型测试","key value is " + obj.getKey());
5. }
7. Generic<Integer> gInteger = new Generic<Integer>(123);
9. Generic<Number> gNumber = new Generic<Number>(456);
13. showKeyValue(gNumber);
17. // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
19. // cannot be applied to Generic<java.lang.Number>
21. // showKeyValue(gInteger);

复制代码

　　
通过提示信息我们可以看到Generic不能被看作为`Generic的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
 
回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic类型的类，这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。
 
我们可以将上面的方法改一下：
 
public void showKeyValue1(Generic obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。
 
可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
 
4.6 泛型方法
一 泛型方法的介绍
 
如果定义类、接口是没有使用类型形参，但定义方法时想自己定义类型形参，这也是可以的，JDK1.5还提供了泛型方法的支持。
 
泛型方法的语法格式为：
 
修饰符  返回值类型 方法名(形参列表)
 
{
 
     //方法体...
 
}
 
泛型方法的方法签名比普通方法的方法签名多了类型形参声明，类型形参声明以尖括号括起来，多个类型形参之间以逗号（,）隔开，所有类型形参声明放在方法修饰符和方法返回值类型之间。
 
 
 
二 泛型方法的正确使用
 
1 代码示例

1. import java.util.*;
5. public class GenericMethodTest
7. {
9.        // 声明一个泛型方法，该泛型方法中带一个T类型形参，
11.        static <T> void fromArrayToCollection(T[] a, Collection<T> c)
13.        {
15.               for (T o : a)
17.               {
19.                      c.add(o);
21.               }
23.        }
25.        public static void main(String[] args)
27.        {
29.               Object[] oa = new Object[100];
31.               Collection<Object> co = new ArrayList<>();
33.               // 下面代码中T代表Object类型
35.               fromArrayToCollection(oa, co);
37.               String[] sa = new String[100];
39.               Collection<String> cs = new ArrayList<>();
41.               // 下面代码中T代表String类型
43.               fromArrayToCollection(sa, cs);
45.               // 下面代码中T代表Object类型
47.               fromArrayToCollection(sa, co);
49.               Integer[] ia = new Integer[100];
51.               Float[] fa = new Float[100];
53.               Number[] na = new Number[100];
55.               Collection<Number> cn = new ArrayList<>();
57.               // 下面代码中T代表Number类型
59.               fromArrayToCollection(ia, cn);
61.               // 下面代码中T代表Number类型
63.               fromArrayToCollection(fa, cn);
65.               // 下面代码中T代表Number类型
67.               fromArrayToCollection(na, cn);
69.               // 下面代码中T代表Object类型
71.               fromArrayToCollection(na, co);
73.               // 下面代码中T代表String类型，但na是一个Number数组，
75.               // 因为Number既不是String类型，
77.               // 也不是它的子类，所以出现编译错误
79. //          fromArrayToCollection(na, cs);
81.        }
83. }

复制代码

　　

1.  

复制代码

 
2 代码说明
 
与类、接口中使用泛型参数不同的是，方法中的泛型参数无需显式传入实际类型参数，因为编译器根据实参推断类型形参的值。它通常推断出最直接的类型参数。例如：调用如下代码。
 
fromArrayToCollection(sa, cs);
上面代码中cs是一个Collection类型，与方法定义时的fromArrayToCollection(T[] a, Collection c)进行比较，只比较泛型参数，不能发现该T类型形参代表的实际类型是String类型。
 
 
 
三 泛型方法的错误使用
 
1 代码示例
 

1. import java.util.*;
5. public class ErrorTest
7. {
9.        // 声明一个泛型方法，该泛型方法中带一个T类型形参
11.        static <T> void test(Collection<T> from, Collection<T> to)
13.        {
15.               for (T ele : from)
17.               {
19.                      to.add(ele);
21.               }
23.        }
25.        public static void main(String[] args)
27.        {
29.               List<Object> as = new ArrayList<>();
31.               List<String> ao = new ArrayList<>();
33.               // 下面代码将产生编译错误
35.               test(as , ao);
37.        }
39. }

复制代码

　　

1.  

复制代码

2 运行结果
错误: 无法将类 ErrorTest中的方法 test应用到给定类型;
                test(as , ao);
                ^
  需要: Collection,Collection
  找到: List,List
  原因: 推断类型不符合等式约束条件
    推断: String
    等式约束条件: String,Object
  其中, T是类型变量:
    T扩展已在方法 test(Collection,Collection)中声明的Object
1 个错误
 
3 代码说明
 
上面程序中调用了test方法传入了两个实际参数，其中as的数据类型是List,而ao的数据类型是List,与泛型方法签名进行对比test(Collection a,Collection c)，编译器无法正确识别T所代表实际类型。
 
 
 
四 改进上面这个例子
 
1 代码示例

  
[code]import java.util.*;public class RightTest{       // 声明一个泛型方法，该泛型方法中带一个T形参       static  void test(Collection