泛型的概念

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

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

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

在集合中使用泛型

总结：
① 集合接口或集合类在 jdk 5 时都修改为带泛型的结构。
② 在实例化集合类时，可以指明具体的泛型类型，指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。比如：add(E e) —->实例化以后：add(Integer e)
③ 泛型的类型必须是类，不能是基本数据类型比如 int，需要用到基本数据类型的位置，拿包装类替换，比如 int 用 Integer 来替换。
④ 实例化时如果没有指明泛型的类型，默认类型为 java.lang.Object 类型。

示例代码

  1. public class GenericTest {
  3.     // 在集合中不适用泛型的时候：
  4.     @Test
  5.     public void test1() {
  6.         ArrayList list = new ArrayList();
  7.         list.add(78);
  8.         list.add(76);
  9.         list.add(89);
  10.         list.add(88);
  11.         // 问题一：类型不安全
  12.         list.add("Tom");
  13.         for (Object score : list) {
  14.             // 问题二：强转时，可能出现ClassCastException
  15.             int stuScore = (Integer) score;
  16.             System.out.println(score);
  17.         }
  18.     }
  20.     // 在集合中使用泛型的情况：以ArrayList为例
  21.     @Test
  22.     public void test2() {
  23.         ArrayList<Integer> list = new ArrayList<>();
  24.         list.add(78);
  25.         list.add(76);
  26.         list.add(89);
  27.         list.add(88);
  28.         // 编译时，就会进行类型检查，保证数据的安全
  29.         // list.add("Tom");
  30.         // 遍历方式一
  31.         for (Integer score : list) {
  32.             // 避免了强转操作
  33.             int stuScore = score;
  34.             System.out.println(stuScore);
  35.         }
  37.         // 遍历方式二：
  38.         Iterator<Integer> iterator = list.iterator();
  39.         while (iterator.hasNext()) {
  40.             int stuScore = iterator.next();
  41.             System.out.println(stuScore);
  42.         }
  43.     }
  45.     // 在集合中使用泛型的情况：以HashMap为例
  46.     @Test
  47.     public void test3() {
  48.         // HashMap<String, Integer> map = new HashMap<String, Integer>();
  49.         // jdk7新特性：类型推断
  50.         HashMap<String, Integer> map = new HashMap<>();
  52.         map.put("Tom", 87);
  53.         map.put("Jerry",87);
  54.         map.put("Jack",67);
  55.         // 编译时，就会进行类型检查，保证数据的安全
  56.         // map.put(123, "ABC");
  58.         //泛型的嵌套
  59.         Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
  60.         Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
  61.         while (iterator.hasNext()) {
  62.             // Entry接口 是 Map 接口的内部接口
  63.             Map.Entry<String, Integer> entry = iterator.next();
  64.             String key = entry.getKey();
  65.             Integer value = entry.getValue();
  66.             System.out.println(key + "::" + value);
  67.         }
  68.     }
  69. }

自定义泛型结构

自定义泛型类或接口

【总结】
1、泛型类可以有多个参数，此时应将多个参数一起放在尖括号内，用逗号隔开，比如：<E1,E2,E3>

2、泛型类的构造器中不能加泛型：public GenericClass(){}，而这个是错误的： public GenericClass<E>(){}

3、实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

4、泛型不同的引用类型变量不能相互赋值（其实赋的是地址），尽管在编译时 ArrayList<String> 和 ArrayList<Integer> 是两种类型，但是运行时只有一个 ArrayList 被加载到JVM中。

5、泛型如果不指定将会被擦除，泛型对应的类型均按照 Object 处理，但不等价于Object。 经验： 泛型要使用就一路都用，要是不用就一路都不要用。

6、如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

7、jdk 7 以后泛型的简化操作： ArrayList<String> list = new ArrayList<>();

8、泛型不能使用基本数据类型，但可以使用包装类来替换。

9、在类或接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为：

  • 非静态属性的类型
  • 非静态方法的参数类型
  • 非静态方法的返回值类型
  • 在静态方法中不能使用类的泛型

10、异常类不能是泛型的。public class MyException<T> extends Exception{}❌

11、不能使用 T[] arr = new T[]❌，但是可以使用：T[] arr = (T[]) new Object[12];

12、父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

  • 子类不保留父类的泛型：按需实现
    • 没有类型：擦除
    • 指明具体类型
  • 子类保留父类的泛型：泛型子类
    • 全部保留
    • 部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

举例说明：
image.png
image.png
image.png

自定义泛型方法

【总结】
1、泛型方法的格式：[``访问权限``] ``<泛型> 返回类型 方法名``([``泛型标识 参数名称``]) ``抛出的异常
2、在泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型。
3、在方法中的泛型参数与类的泛型参数没有任何关系，泛型方法所属的类或接口带不带泛型都可以。
4、泛型方法可以声明为 static

举例说明
DAO就不是泛型类，也可以定义泛型方法：
image.png

泛型在继承上的体现

【总结】

  • 如果 A 是 B 的父类或父接口，G 是具有泛型声明的类或接口，则 G<A> 和G<B>二者不具备子父类关系，二者是并列关系，比如 List<String > 并不是 List<Object> 的子类 。
  • 如果 A 是 B 的父类或父接口，G是泛型参数，则 A<G> 是 B<G> 的父类或父接口，比如 List<String> 是 ArrayList<String> 的父类。

示例代码

  1. @Test
  2. public void test1() {
  3.     Object obj = null;
  4.     String str = null;
  5.     // 多态
  6.     obj = str;
  8.     Object[] arr1 = null;
  9.     String[] arr2 = null;
  10.     // 编译不通过
  11.     List<Object> list1 = null;
  12.     List<String> list2 = new ArrayList<>();
  13.     // 此时的list1和list2的类型不具有子父类关系
  14.     // 编译不通过
  15.     // list1 = list2;
  16.     /*
  17.     反证法：
  18.         假设list1 = list2;
  19.         那么list1.add(123);会导致混入非String的数据，出错。
  20.     */
  22.     List<String> list3 = null;
  23.     ArrayList<String> list4 = null;
  24.     // 编译通过
  25.     list3 = list4;
  26. }

通配符的使用

类型通配符：？

如果 A 是 B 的父类或父接口，G 是具有泛型声明的类或接口，则 G<A> 和 G<B> 二者不具备子父类关系，二者是并列关系，二者共同的父类是：G<?>，比如：List<?> 是 List<String>、 List<Object>等各种泛型 List 的父类。

关于 List<?> 的对象 list 中的元素的读取和写入

  • 读取时永远是安全的，因为不管 list 的真实类型是什么，它包含的都是Object。我们可以调用 get() 方法并使用其返回值。返回值是一个未知的类型，但是我们知道它总归是一个Object。
  • 写入数据是不行的，因为我们不知道具体的元素类型，不能向其中添加对象。
    • 唯一的例外的是可以传入 null，因为它是所有类型的成员。

【注意点】

  • ？通配符不能用在泛型方法声明上，返回值类型前面的<>内也不能使用
  • ？通配符不能用在泛型类的声明上
  • ？通配符不能用在创建对象上

image.png

【示例代码】

  1.     @Test
  2.     public void test2() {
  3.         List<Object> list1 = null;
  4.         List<String> list2 = null;
  5.         List<?> list = null;
  7.         // 编译通过
  8.         list = list1;
  9.         list = list2;
  10. //        print(list1);
  11. //        print(list2);
  13.         // 添加(写入)：除了添加null之外，对于List<?>就不能向其内部添加数据。
  14.         List<String> list3 = new ArrayList<>();
  15.         list3.add("AA");
  16.         list3.add("BB");
  17.         list = list3;
  18.         // 运行不通过
  19. //        list.add("CC");
  20. //        list.add('?');
  21.         // 运行可以通过
  22.         list.add(null);
  24.         //获取(读取)：允许读取数据，读取的数据类型为Object。
  25.         Object obj = list.get(0);
  26.         System.out.println(obj);
  28.     }
  30.     public void print(List<?> list){
  31.         Iterator<?> iterator = list.iterator();
  32.         while(iterator.hasNext()){
  33.             Object obj = iterator.next();
  34.             System.out.println(obj);
  35.         }
  36.     }

有限制的通配符

  • 上限 extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即 <=
    • 举例：<? extends Number> 类似于 (无穷小 , Number] 区间，只允许泛型为 Number 及 Number 子类的引用调用。
  • 下限 super：使用时指定的类型不能小于操作的类，即 >=
    • 举例：<? super Number> 类似于 [Number, 无穷大) 区间，只允许泛型为 Number 及 Number 父类的引用调用

【示例代码】其中，Person类是Student类的父类。

  1.     @Test
  2.     public void test3() {
  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.         // 编译不通过
  13.         // list1 = list5;
  15.         // 编译不通过
  16.         // list2 = list3;
  17.         list2 = list4;
  18.         list2 = list5;
  20.         //读取数据：
  21.         list1 = list3;
  22.         Person p = list1.get(0);
  23.         //编译不通过
  24.         //Student s = list1.get(0);
  26.         list2 = list4;
  27.         Object obj = list2.get(0);
  28.         ////编译不通过
  29. //        Person obj = list2.get(0);
  31.         //写入数据：
  32.         //编译不通过
  33. //        list1.add(new Student());
  35.         //编译通过
  36.         list2.add(new Person());
  37.         list2.add(new Student());
  38.     }

拓展文章

尚硅谷宋红康_Java基础泛型.pdf