1. 为什么使用泛型

1.1 泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList这个<E>就是类型参数，即泛型。

1.2 概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承类、实现接口、用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

JDK1.5引入了参数化类型（Parameterized type）的概念， 允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。

JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持， 从而可以在声明集合变量、创建集合对象时传入类型实参。

1.3 泛型的优点

为什么要有泛型，直接Object不是也可以存储数据吗？

  1. 解决元素存储的安全性问题，不会存储进错误类型的元素；
  2. 解决获取数据元素时，需要类型强制转换的问题；
  3. 能够在编译时而不是在运行时检测错误；
  4. 如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException异常；
  5. 代码更加简洁、健壮；

9 泛型 - 图1
9 泛型 - 图2

1.4 演示在集合中使用泛型

  1. public class GenericTest {
  2.     //在集合中使用泛型之前的情况：存放学生的成绩
  3.     @Test
  4.     public void test1(){
  5.         ArrayList list = new ArrayList();
  6.         list.add(78);
  7.         list.add(76);
  8.         //list.add("Tom");//问题一：类型不安全
  9.         for(Object score : list){
  10.             int stuScore = (Integer) score;//问题二：强转时，可能出现ClassCastException
  11.             System.out.println(stuScore);
  12.         }
  13.     }
  14.     //在集合中使用泛型的情况：以ArrayList为例
  15.     @Test
  16.     public void test2(){
  17.        ArrayList<Integer> list =  new ArrayList<Integer>();
  18.         list.add(78);
  19.         list.add(87);
  20.         //list.add("Tom");//编译时，就会进行类型检查，保证数据的安全
  21.         //遍历方式一：
  22.         for(Integer score : list){
  23.             int stuScore = score;//避免了强转操作
  24.             System.out.println(stuScore);
  25.         }
  26.         //遍历方式二：
  27.         Iterator<Integer> iterator = list.iterator();
  28.         while(iterator.hasNext()){
  29.             int stuScore = iterator.next();
  30.             System.out.println(stuScore);
  31.         }
  32.     }
  33.     //在集合中使用泛型的情况：以HashMap为例
  34.     @Test
  35.     public void test3(){
  36.         //Map<String,Integer> map = new HashMap<String,Integer>();
  37.         Map<String,Integer> map = new HashMap<>();//jdk7新特性：类型推断
  38.         map.put("Tom",87);
  39.         map.put("Jerry",87);
  40.         //map.put(123,"ABC");//添加失败
  41.         //泛型的嵌套
  42.         Set<Map.Entry<String,Integer>> entry = map.entrySet();
  43.         Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
  44.         while(iterator.hasNext()){
  45.             Map.Entry<String, Integer> e = iterator.next();
  46.             String key = e.getKey();
  47.             Integer value = e.getValue();
  48.             System.out.println(key + "----" + value);
  49.         }
  50.     }
  51. }

2. 自定义泛型结构

2.1. 自定义泛型类、接口

注意点：

  1. 泛型类可以有多个参数，此时应将多个参数一起放在尖括号内。比如：
  2. 在实例化类时，可以指明具体的泛型的类型，如果没有指明泛型，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
  3. 实例化时指明泛型的类型以后，类的内部结构（比如：方法、构造器、属性等）凡是使用到泛型的位置，都指定为实例化时的泛型类型，并且操作原来泛型位置的结构必须与指定的泛型类型一致。
  4. jdk1.7 新增泛型的简化操作，即类型推断：ArrayList flist = new ArrayList<>();
  5. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  6. 指明具体的泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。
  7. 在类或接口上声明的泛型，在本类或本接口中代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型、构造器的参数类型。但在静态方法中、在try-catch中不能使用泛型。
  8. 异常类不能是泛型的，包括异常类的子类。
  9. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
    参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
  10. 父类有泛型，如 class Father，子类除了不保留或保留父类的泛型，还可以增加自己的泛型：
    1. 子类不保留父类的泛型：子类不是泛型
      没有/擦除父类泛型：class Son1 extends Father，等价于class Son1 extends Father
      指明父类泛型：class Son2 extends Father
    2. 子类保留父类的泛型：子类是泛型
      全部保留父类泛型：class Son3 extends Father
      部分保留父类泛型：class Son4 extends Father
    3. 子类增加自己的泛型

没有/擦除父类泛型：class Son extends Father
指明父类泛型：class Son2 extends Father
全部保留父类泛型：class Son3 extends Father
部分保留父类泛型：class Son4 extends Father

  1. 泛型不同的引用不能相互赋值。尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
  1. public class Order<T> {
  2.     String orderName;
  3.     int orderId;
  4.     T orderT;// 使用类的泛型定义变量的类型
  5.     public Order(){
  6.     }
  7.     public Order(String orderName,int orderId,T orderT){// 使用类的泛型定义构造器的参数类型
  8.         this.orderName = orderName;
  9.         this.orderId = orderId;
  10.         this.orderT = orderT;
  11.     }
  12.     public T getOrderT(){// 使用类的泛型定义一般方法的返回值类型，但不是泛型方法
  13.         return orderT;
  14.     }
  15.     public void setOrderT(T orderT){// 使用类的泛型定义一般方法的的参数类型，但不是泛型方法
  16.         this.orderT = orderT;
  17.     }
  18. }
  1. public class SubOrder1<T> extends Order<T> {}
  1. public class SubOrder2 extends Order<Integer> { }
  1. public class GenericTest1 {
  2.     @Test
  3.     public void test1(){
  4.         //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
  5.         Order order = new Order();
  6.         order.setOrderT(123);
  7.         order.setOrderT("ABC");
  8.         //建议：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
  9.         Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
  10.         order1.setOrderT("AA:hello");
  11.     }
  12.      @Test
  13.     public void test2(){
  14.         SubOrder1<String> sub1 = new SubOrder1<>();
  15.         sub1.setOrderT("order1...");
  16.         SubOrder2 sub2 = new SubOrder2();
  17.         //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
  18.         sub2.setOrderT(1122);
  19.     }
  1.     @Test
  2.     public void test3(){
  3.         ArrayList<String> list1 = null;
  4.         ArrayList<Integer> list2 = new ArrayList<Integer>();
  5.         //list1 = list2; //泛型不同的引用不能相互赋值
  6.     }
  1. //public class MyException<T> extends Exception{
  2. //}

3.2. 自定义泛型方法

注意点：

  1. 泛型方法的格式：[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
  2. 在方法中出现了泛型的结构，方法的泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。
  3. 在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
  4. 泛型方法可以声明为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。
  1. public class Order<T> {
  2.     String orderName;
  3.     int orderId;
  4.     T orderT;
  5.     public Order(){
  6.         //T[] arr = new T[10];//编译不通过
  7.         T[] arr = (T[]) new Object[10];//编译通过
  8.     }
  9.     public Order(String orderName,int orderId,T orderT){
  10.         this.orderName = orderName;
  11.         this.orderId = orderId;
  12.         this.orderT = orderT;
  13.     }
  14.     public T getOrderT(){
  15.         return orderT;
  16.     }
  17.     public void setOrderT(T orderT){
  18.         this.orderT = orderT;
  19.     }
  20.     public static <E>  List<E> copyFromArrayToList(E[] arr){//泛型方法
  21.         ArrayList<E> list = new ArrayList<>();
  22.         for(E e : arr){
  23.             list.add(e);
  24.         }
  25.         return list;
  26.     }
  1.     @Test
  2.     public void test4(){
  3.         Order<String> order = new Order<>();
  4.         Integer[] arr = new Integer[]{1,2,3,4};
  5.         //泛型方法在调用时，指明泛型参数的类型
  6.         List<Integer> list = order.copyFromArrayToList(arr);
  7.         System.out.println(list);
  8.     }

4. 泛型在继承方面的体现

虽然类B是类A的子类或子接口，但是 G 和 G 二者不具备父子类关系，二者是并列关系。
补充：类A是类B的父类，A 是 B 的父类。

  1.     @Test
  2.     public void test1(){
  3.         Object obj = null;
  4.         String str = null;
  5.         obj = str;
  7.         Object[] arr1 = null;
  8.         String[] arr2 = null;
  9.         arr1 = arr2;
  11.         Date date = new Date();
  12.         //str = date;//编译不通过
  14.         List<Object> list1 = null;
  15.         List<String> list2 = new ArrayList<String>();
  16.         //list1 = list2;//编译不通过
  17.         //假设list1 = list2; list1.add(123);导致混入非String的数据。出错。
  19.         show(list1);
  20.         show1(list2);
  21.         show(list2);//编译失败
  22.         show1(listl);//编译失败
  23.     }
  25.     public void show(List<Object> list){}
  26.     public void show1(List<String> list){}
  28.     @Test
  29.     public void test2(){
  30.         AbstractList<String> list1 = null;
  31.         List<String> list2 = null;
  32.         ArrayList<String> list3 = null;
  33.         list1 = list3;
  34.         list2 = list3;
  35.         List<String> list4 = new ArrayList<>();
  36.     }

5. 通配符的使用

5.1. 通配符的简单使用

注意点：

  1. 类型通配符：?
  2. 类A是类B的父类，G和G是没有关系的，二者共同的父类是：G<?>。
  3. 比如：List<?>是 List、List 等各种泛型List的父类。
  4. 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。

  5. 加入list中的元素不能是任意类型的，将任意元素加入到其中不是类型安全的，因为我们不知道list中元素的类型。例外，null是所有类型的成员。

    例如：Collection<?> c = new ArrayList(); c.add(new Object()); // 编译时错误

  6. 在泛型方法声明上，返回值类型前面的<>不能使用?

  7. 在泛型类的声明上，不能使用?
  8. 在创建对象的new 类<>上，不能使用?
    1.     @Test
    2.     public void test3(){
    3.         List<Object> list1 = null;
    4.         List<String> list2 = null;
    5.         List<?> list = null;
    7.         list = list1;
    8.         list = list2;
    10.         List<String> list3 = new ArrayList<>();
    11.         list3.add("AA");
    12.         list3.add("BB");
    13.         list = list3;
    15.         //添加(写入)：对于List<?>就不能向其内部添加数据，除了添加null之外。
    16.         //list.add("DD");
    17.         //list.add('?');
    18.         list.add(null);
    20.         //获取(读取)：允许读取数据，读取的数据类型为Object。
    21.         Object o = list.get(0);
    22.         System.out.println(o);
    23.     }
    25.     public void print(List<?> list){
    26.         Iterator<?> iterator = list.iterator();
    27.         while(iterator.hasNext()){
    28.             Object obj = iterator.next();
    29.             System.out.println(obj);
    30.         }
    31.     }

    5.2. 有限制条件的通配符的使用

    注意点：

    1. <?> 允许所有泛型的引用调用
    2. 通配符指定上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
    3. 通配符指定下限super：使用时指定的类型不能小于操作的类，即>=
    4. 举例

    <? extends Number> (无穷小 , Number] 只允许泛型为Number及Number子类的引用调用
    <? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
    <? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用
    G<? extends A> 可以作为G和G的父类，其中B是A的子类
    G<? super A> 可以作为G    和G的父类，其中B是A的父类

    1.     @Test
    2.     public void test4(){
    3.         List<? extends Person> list1 = null;
    4.         List<? super Person> list2 = null;
    6.         List<Student> list3 = new ArrayList<Student>();
    7.         List<Person> list4 = new ArrayList<Person>();
    8.         List<Object> list5 = new ArrayList<Object>();
    10.         list1 = list3;
    11.         list1 = list4;
    12.         //list1 = list5;
    14.         //list2 = list3;
    15.         list2 = list4;
    16.         list2 = list5;
    18.         //读取数据：
    19.         list1 = list3;
    20.         Person p = list1.get(0);
    21.         //编译不通过
    22.         //Student s = list1.get(0);
    24.         list2 = list4;
    25.         Object obj = list2.get(0);
    26.         //编译不通过
    27.         //Person obj = list2.get(0);
    29.         //写入数据：
    30.         //编译不通过，因为list1的范围是<=Person，万一?是比Student还小的子类，就不能把父类赋值给子类
    31.         //list1.add(new Student());
    33.         //编译通过，因为list2的范围是>=Person,可以把子类赋给父类，
    34.         list2.add(new Person());
    35.         list2.add(new Student());
    36.     }