1. 泛型概述

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

泛型引用和创建两端，给出的泛型变量必须相同。

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

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

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

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

  1.   Map m = new HashMap();
  2.   m.put("key", "blarg");
  3.   String s = (String) m.get("key");

要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西，这样的话，上面的代码将会抛出 ClassCastException。

理想情况下，您可能会得出这样一个观点，即 m 是一个 Map，它将 String 键映射到 String 值。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。

泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。

  1. package cn.itcast_01;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  6. /*
  7.  * ArrayList存储字符串并遍历
  8.  * 
  9.  * 我们按照正常的写法来写这个程序， 结果确出错了。
  10.  * 为什么呢?
  11.  *         因为我们开始存储的时候，存储了String和Integer两种类型的数据。
  12.  *         而在遍历的时候，我们把它们都当作String类型处理的，做了转换，所以就报错了。
  13.  * 但是呢，它在编译期间却没有告诉我们。
  14.  * 所以，我就觉得这个设计的不好。
  15.  * 回想一下，我们的数组
  16.  *         String[] strArray = new String[3];
  17.  *         strArray[0] = "hello";
  18.  *         strArray[1] = "world";
  19.  *         strArray[2] = 10;
  20.  * 集合也模仿着数组的这种做法，在创建对象的时候明确元素的数据类型。这样就不会在有问题了。
  21.  * 而这种技术被称为：泛型。
  22.  * 
  23.  * 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
  24.  * 格式：
  25.  *         <数据类型>
  26.  *         此处的数据类型只能是引用类型。
  27.  * 好处：
  28.  *         A:把运行时期的问题提前到了编译期间
  29.  *         B:避免了强制类型转换
  30.  *         C:优化了程序设计，解决了黄色警告线
  31.  */
  32. public class GenericDemo {
  33.     public static void main(String[] args) {
  34.         // 创建
  35.         ArrayList<String> array = new ArrayList<String>();
  37.         // 添加元素
  38.         array.add("hello");
  39.         array.add("world");
  40.         array.add("java");
  41.         // array.add(new Integer(100));
  42.         //array.add(10); // JDK5以后的自动装箱
  43.         // 等价于：array.add(Integer.valueOf(10));
  45.         // 遍历
  46.         Iterator<String> it = array.iterator();
  47.         while (it.hasNext()) {
  48.             // ClassCastException
  49.             // String s = (String) it.next();
  50.             String s = it.next();
  51.             System.out.println(s);
  52.         }
  54.         // 看下面这个代码
  55.         // String[] strArray = new String[3];
  56.         // strArray[0] = "hello";
  57.         // strArray[1] = "world";
  58.         // strArray[2] = 10;
  59.     }
  60. }

2. 泛型的好处

简言之，泛型能够使类型（类和接口）在定义类，接口和方法的时候参数化。非常像方法定义时用到的形式参数（formal parameters）,类型参数提供了一种你可以通过不同的输入来复用同一段代码的方法。不同点是，形式参数输入的是值，而类型参数输入的是类型。

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

  • 编译时更强大的类型检测
  • 消除类型转换(Elimination of casts)
  • 使开发者实现泛型算法

2.1 类型安全

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

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

2.2 消除强制类型转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的罗嗦。

2.3 优化了程序设计，解决了黄色警告线

3. 泛型的应用

3.1 泛型的内部原理

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入。但是，编译器编译带类型说明的集合时会去除掉“类型”信息，目的就是使程序运行效率不受影响。因此，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。

  1. package com.itheima.day2;
  3. import java.util.ArrayList;
  5. public class GenericTest {
  7.        public static void main(String[] args) {
  8.             ArrayList<String> collection1 = new ArrayList<String>();
  9.             ArrayList collection2 = new ArrayList();
  10.             System. out.println(collection1.getClass() == collection2.getClass());
  11.              //结果：true
  12.       }
  13. }

由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

  1. package com.itheima.day2;
  3. import java.util.ArrayList;
  5. public class GenericTest {
  7.        public static void main(String[] args) throws Exception {
  8.             ArrayList<Integer> collection1 = new ArrayList<Integer>();
  9.             collection1.getClass().getMethod( "add",Object.class).invoke(collection1, "abc");
  10.             System. out.println(collection1.get(0));
  11.       }
  12. }

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

  • 整个称为ArrayList<E>泛型类型
  • ArrayList<E>中的E称为类型变量或类型参数
  • 整个ArrayList<Integer>称为参数化的类型
  • ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
  • ArrayList<Integer>中的<>念着typeof
  • ArrayList称为原始类型

参数化类型与原始类型的兼容性：参数化类型可以引用一个原始类型的对象，编译报告警告，例如

  1. Collection<String> c = new Vector();//考虑到对以前代码的兼容性，编译器是可以通过的

原始类型可以引用一个参数化类型的对象，编译报告警告，例如

  1. Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

参数化类型不考虑类型参数的继承关系：

  1. Vector<String> v = new Vector<Object>(); //错误!不写<Object>没错，写了就是明知故犯
  2. Vector<Object> v = new Vector<String>(); //也错误!

注意：

假设Vector<String> v = new Vector<Object>();可以的话，那么以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象；

假设Vector<Object> v = new Vector<String>();可以的话，那么以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象。

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型。

例如，下面语句有错误：

  1. Vector<Integer> vectorList[] = new Vector<Integer>[10];

思考题：

下面的代码会报错误吗？

  1. Vector v1 = new Vector<String>();
  2. Vector<Object> v = v1;

答案：编译的时候是不会报错的，因为编译器是一行一行按照语法检查代码的，因此不会出错。

3.2 泛型擦除

泛型会在编译时擦除，List<String>和List<User>这两个的字节码文件那一个都是List.class

Java泛型的实现机制，使用了泛型的代码在运行期间相关的泛型参数的类型会被擦除，我们无法在运行期间获知泛型参数的具体类型（所有的泛型类型在运行时都是Object类型）。但是编译java源代码生成的Class文件中还是保存了泛型相关的信息，这些信息被保存在class字节码常量池中，使用了泛型的代码处会生成一个signature签名字段，该签名signature字段指明了这个常量池的地址，于是可从该常量池中获取到具体的类型。

4. 泛型类

把泛型定义在类上，格式:public class 类名<泛型类型1,…>，注意:泛型类型必须是引用类型

  1. A<T>
  2. Class<T> type

泛型类中使用泛型

  • 成员类型
  • 返回值和参数类型
  • 局部变量的引用上
  1. class A<T> {
  2.     private T bean;//泛型可在成员变量上使用
  3.     public T fun(T t) {}//泛型可以在类中的方法上（返回值和参数类型）使用！
  4.     public void fun2() {//泛型还可以在局部变量的引用类型上使用
  5.         T b = ...
  6.         new T();//不行的！
  7.     }
  8. }
  1. package cn.itcast_04;
  3. /*
  4.  * 泛型类的测试
  5.  */
  6. public class ObjectToolDemo {
  7.     public static void main(String[] args) {
  8.         // ObjectTool ot = new ObjectTool();
  9.         //
  10.         // ot.setObj(new String("风清扬"));
  11.         // String s = (String) ot.getObj();
  12.         // System.out.println("姓名是：" + s);
  13.         //
  14.         // ot.setObj(new Integer(30));
  15.         // Integer i = (Integer) ot.getObj();
  16.         // System.out.println("年龄是：" + i);
  18.         // ot.setObj(new String("林青霞"));
  19.         // // ClassCastException
  20.         // Integer ii = (Integer) ot.getObj();
  21.         // System.out.println("姓名是：" + ii);
  23.         System.out.println("-------------");
  25.         ObjectTool<String> ot = new ObjectTool<String>();
  26.         // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
  27.         ot.setObj(new String("林青霞"));
  28.         String s = ot.getObj();
  29.         System.out.println("姓名是：" + s);
  31.         ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
  32.         // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
  33.         ot2.setObj(new Integer(27));
  34.         Integer i = ot2.getObj();
  35.         System.out.println("年龄是：" + i);
  36.     }
  37. }
  38. //泛型类：把泛型定义在类上
  39. class ObjectTool<T> {
  40.     private T obj;
  42.     public T getObj() {
  43.         return obj;
  44.     }
  46.     public void setObj(T obj) {
  47.         this.obj = obj;
  48.     }
  49. }

5. 泛型方法

把泛型定义在方法上，格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

  1. public <T> T add(T x, T y){ 
  2. }

泛型方法与泛型类没有什么关系，泛型方法不一定非要在泛型类中！

  1. package cn.itcast_05;
  3. public class ObjectToolDemo {
  4.     public static void main(String[] args) {
  5.         // ObjectTool ot = new ObjectTool();
  6.         // ot.show("hello");
  7.         // ot.show(100);
  8.         // ot.show(true);
  10.         // ObjectTool<String> ot = new ObjectTool<String>();
  11.         // ot.show("hello");
  12.         //
  13.         // ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
  14.         // ot2.show(100);
  15.         //
  16.         // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();
  17.         // ot3.show(true);
  19.         // 定义泛型方法后
  20.         ObjectTool ot = new ObjectTool();
  21.         ot.show("hello");
  22.         ot.show(100);
  23.         ot.show(true);
  24.     }
  25. }
  26. //泛型方法：把泛型定义在方法上
  27. class ObjectTool {
  28.     public <T> void show(T t) {
  29.         System.out.println(t);
  30.     }
  31. }

6. 泛型接口

把泛型定义在接口上，格式:public interface 接口名<泛型类型1…>

  1. package cn.itcast_06;
  3. public class InterDemo {
  4.     public static void main(String[] args) {
  5.         // 第一种情况的测试
  6.         // Inter<String> i = new InterImpl();
  7.         // i.show("hello");
  9.         // // 第二种情况的测试
  10.         Inter<String> i = new InterImpl<String>();
  11.         i.show("hello");
  13.         Inter<Integer> ii = new InterImpl<Integer>();
  14.         ii.show(100);
  15.     }
  16. }
  17. //泛型接口：把泛型定义在接口上 
  18. interface Inter<T> {
  19.     public abstract void show(T t);
  20. }
  21. // 实现类在实现接口的时候
  22. // 第一种情况：已经知道该是什么类型的了
  24. //public class InterImpl implements Inter<String> {
  25. //
  26. //    @Override
  27. //    public void show(String t) {
  28. //        System.out.println(t);
  29. //    }
  30. // }
  32. // 第二种情况：还不知道是什么类型的
  33. class InterImpl<T> implements Inter<T> {
  35.     @Override
  36.     public void show(T t) {
  37.         System.out.println(t);
  38.     }
  39. }

7. 通配符

为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为<? extends Collection>，“?”代表未知类型，这个类型是实现Collection接口。? extends E：向下限定，E及其子类，限定通配符的上边界。? super E：向上限定，E及其父类，限定通配符的下边界。

  • 无限通配符<?>
  • 向下通配符<? extends T>
  • 向上通配符<? super T>
  1. package cn.itcast_07;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  6. /*
  7.  * 泛型高级(通配符)
  8.  * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
  9.  * ? extends E:向下限定，E及其子类
  10.  * ? super E:向上限定，E极其父类
  11.  */
  12. public class GenericDemo {
  13.     public static void main(String[] args) {
  14.         // 泛型如果明确的写的时候，前后必须一致
  15.         Collection<Object> c1 = new ArrayList<Object>();
  16.         // Collection<Object> c2 = new ArrayList<Animal>();
  17.         // Collection<Object> c3 = new ArrayList<Dog>();
  18.         // Collection<Object> c4 = new ArrayList<Cat>();
  20.         // ?表示任意的类型都是可以的
  21.         Collection<?> c5 = new ArrayList<Object>();
  22.         Collection<?> c6 = new ArrayList<Animal>();
  23.         Collection<?> c7 = new ArrayList<Dog>();
  24.         Collection<?> c8 = new ArrayList<Cat>();
  26.         // ? extends E:向下限定，E及其子类
  27.         // Collection<? extends Animal> c9 = new ArrayList<Object>();
  28.         Collection<? extends Animal> c10 = new ArrayList<Animal>();
  29.         Collection<? extends Animal> c11 = new ArrayList<Dog>();
  30.         Collection<? extends Animal> c12 = new ArrayList<Cat>();
  32.         // ? super E:向上限定，E极其父类
  33.         Collection<? super Animal> c13 = new ArrayList<Object>();
  34.         Collection<? super Animal> c14 = new ArrayList<Animal>();
  35.         // Collection<? super Animal> c15 = new ArrayList<Dog>();
  36.         // Collection<? super Animal> c16 = new ArrayList<Cat>();
  37.     }
  38. }
  40. class Animal {
  41. }
  43. class Dog extends Animal {
  44. }
  46. class Cat extends Animal {
  47. }

8. 泛型的继承和实现

  1. class A<T> {
  2. }
  4. // AA不是泛型类，只是它爸爸是泛型类！
  5. class AA extends A<String> {
  7. }

继承泛型类

  • 子类不是泛型类：需要给父类传递类型常量

当给父类传递的类型常量为String时，那么在父类中所有T都会被String替换！

  1. class AA1 extends A<String> {
  3. }
  • 子类是泛型类：可以给父类传递类型常量，也可以传递类型变量
  1. class AA3<E> extends A<E> {
  3. }

9. 类型推断

  • 通过反射的方式获取泛型的实际类型
  1. // 方式1：使用反射
  2. Class<? super T> rawType;
  3. ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
  5. // 方式2：使用Gson
  6. public BaseCallback() {
  7.     this.mType = getSuperclassTypeParameter(getClass());
  8.     this.rawType = (Class<? super T>) $Gson$Types.getRawType(mType);
  9. }
  11. static Type getSuperclassTypeParameter(Class<?> subclass) {
  12.     Type superclass = subclass.getGenericSuperclass();
  13.     if (superclass instanceof Class) {
  14.         throw new RuntimeException("Missing type parameter.");
  15.     }
  16.     ParameterizedType parameterized = (ParameterizedType) superclass;
  17.     return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
  18. }
  • 泛型只能是引用类型，不能是基本数据类型

10. Type

Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型

ParameterizedType

ParameterizedType 表示参数化类型，如 Collection<String>

方法 说明
Type[ ] getActualTypeArguments() 获取真实参数 
  1. public abstract class BaseProtocol<T> {
  2.     ...
  3.     // 泛型解析
  4.     protected T parsejson(String jsonString){
  5.         ParameterizedType genericSuperclass = (ParameterizedType) getClass().getGenericSuperclass();
  6.         Type[] args = genericSuperclass.getActualTypeArguments();
  7.         Type type = args[0];
  8.         return GsonUtil.changeGsonToBean(jsonString,type);
  9.     }
  10. }

11. 泛型在代码封装中的应用

ViewHolder的封装

  1. public class SuperViewHolder extends RecyclerView.ViewHolder {
  3.     private SparseArray<View> views;
  5.     public SuperViewHolder(View itemView) {
  6.         super(itemView);
  7.         this.views = new SparseArray<>();
  8.     }
  10.       // 泛型方法
  11.     public <T extends View> T getView(int viewId) {
  12.         View view = views.get(viewId);
  13.         if (view == null) {
  14.             view = itemView.findViewById(viewId);
  15.             views.put(viewId, view);
  16.         }
  17.         return (T) view;
  18.     }
  20.     public SuperViewHolder setText(int viewId, String text) {
  21.         TextView tv = getView(viewId);
  22.         tv.setText(text);
  23.         return this;
  24.     }
  25. }

网络请求回调接口的封装

  1. public abstract class BaseCallBack<T> {
  3.     Type type;
  4.     static Type getSuperclassTypeParameter(Class<?> subclass)
  5.     {
  6.         Type superclass = subclass.getGenericSuperclass();
  8.         if (superclass instanceof Class)
  9.         {
  10.             throw new RuntimeException("Missing type parameter.");
  11.         }
  12.         ParameterizedType parameterized = (ParameterizedType) superclass;
  13.         return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
  14.     }
  16.     public BaseCallBack()
  17.     {
  18.         type = getSuperclassTypeParameter(getClass());
  19.     }
  21.     public abstract void onFailure(Call call, IOException e);
  23.     public abstract void onSuccess(Call call, T t);
  24. }