javajavase
尚硅谷宋红康第12章_泛型.pdf

简介

泛型：标签
引入背景

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

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

  • 从JDK1.5以后，Java引入了“参数化类型(Parameterized type)”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象
  • JDK1.5改写了集合框架中的全部接口和类，增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参

引入目的

  1. 解决元素存储的安全性问题。好比商品、药品标签，不会弄错
  2. 解决获取数据元素时需要类型强制转换的问题。好比不用每回拿商品、药品都要辨别

屏幕快照 2020-05-23 下午10.23.50.png
屏幕快照 2020-05-23 下午10.24.58.png

Java泛型可以保证如果程序在编译时没有发岀警告，运行时就不会产生ClassCastException异常 同时，代码更加简洁、健壮

集合中使用

在集合中没有使用泛型的例子

  1. @Test
  2. public void test1() {
  3.     ArrayList list = new ArrayList();
  4.     // 需求：存放学生的成绩
  5.     list.add(78);
  6.     list.add(76);
  7.     list.add(89);
  8.     list.add(88);
  10.     //问题一：类型不安全
  11.     //        list.add("Tom");
  13.     for (Object score : list) {
  14.         // 问题二：强转时，可能出现ClassCastException
  15.         int stuScore = (Integer) score;
  16.         System.out.println(stuScore);
  17.     }
  18. }

在集合中使用泛型

  • 集合接口或集合类在JDK1.5时都修改为带泛型的结构，实例化集合类时可以指明具体的泛型类型
  • 指明后，集合类或接口中凡是定义类或接口时，内部结构（方法、构造器、属性等）使用到类的泛型的位置都变为实例化的泛型类型
    • 比如：add(E e) —->实例化以后：add(Integer e)
  • 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

  • 如果实例化时没有指明泛型的类型，默认类型为Object类型

    1. //在集合中使用泛型的情况：以ArrayList为例
    2. @Test
    3. public void test2() {
    4.   ArrayList<Integer> list = new ArrayList<Integer>();
    6.   list.add(78);
    7.   list.add(87);
    8.   list.add(99);
    9.   list.add(65);
    11.   // 编译时，就会进行类型检查，保证数据的安全
    12.   //        list.add("Tom");
    14.   // 方式一：
    15.   for(Integer score : list) {
    16.       // 避免了强转操作
    17.       int stuScore = score;
    18.       System.out.println(stuScore);
    19.   }
    21.   //方式二：
    22.   Iterator<Integer> iterator = list.iterator();
    23.   while (iterator.hasNext()) {
    24.       int stuScore = iterator.next();
    25.       System.out.println(stuScore);
    26.   }
    27. }
    1. // 在集合中使用泛型的情况：以HashMap为例
    2. @Test
    3. public void test3() {
    4.   //         Map<String, Integer> map = new HashMap<String, Integer>();
    5.   // jdk7新特性：类型推断
    6.   Map<String, Integer> map = new HashMap<>();
    8.   map.put("Tom", 87);
    9.   map.put("Jerry", 87);
    10.   map.put("Jack", 67);
    11.   //        map.put(123,"ABC");
    13.   // 泛型的嵌套
    14.   Set<Map.Entry<String, Integer>> entry = map.entrySet();
    15.   Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    17.   while (iterator.hasNext()) {
    18.       Map.Entry<String, Integer> e = iterator.next();
    19.       String key = e.getKey();
    20.       Integer value = e.getValue();
    21.       System.out.println(key + "----" + value);
    22.   }
    23. }

自定义泛型结构

泛型类、泛型接口、泛型方法
泛型的声明
interface List和class HashMap，其中T、K、V表示类型，任意字母都可以，常用T表示Type
泛型的实例化

  • 一定要在类名后面指定类型参数的值（类型）。如：

List strList =new ArrayList();
Iterator iterator = customers.iterator();

  • T只能是类，不能用基本数据类型，可以使用包装类
  • 把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想

屏幕快照 2020-05-23 下午10.41.07.png

自定义泛型类、接口

  1. // 自定义泛型类Order
  2. public class Order<T> {
  3.     String orderName;
  4.     int orderId;
  6.     // 类的内部结构就可以使用类的泛型
  7.     T orderT;
  9.     public Order() {
  10.         // 🔴编译不通过
  11.         //        T[] arr = new T[10];
  12.         // 编译通过
  13.         T[] arr = (T[]) new Object[10];
  14.     }
  16.     public Order(String orderName, int orderId, T orderT) {
  17.         this.orderName = orderName;
  18.         this.orderId = orderId;
  19.         this.orderT = orderT;
  20.     }
  22.     // 如下的三个方法都不是泛型方法
  23.     public T getOrderT() {
  24.         return orderT;
  25.     }
  27.     public void setOrderT(T orderT) {
  28.         this.orderT = orderT;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Order{" +
  34.                 "orderName='" + orderName + '\'' +
  35.                 ", orderId=" + orderId +
  36.                 ", orderT=" + orderT +
  37.                 '}';
  38.     }
  40.     // 🔴静态方法中不能使用类的泛型，生命周期
  41.     //    public static void show(T orderT) {
  42.     //        System.out.println(orderT);
  43.     //    }
  45.     public void show() {
  46.         // 编译不通过
  47.         //        try{
  48.         //        }catch(T t){
  49.         //        }
  50.     }
  52.     // 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
  53.     // 换句话说，泛型方法所属的类是不是泛型类都没有关系。
  54.     // 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
  55.     public static <E> List<E> copyFromArrayToList(E[] arr) {
  56.         ArrayList<E> list = new ArrayList<>();
  57.         for (E e : arr) {
  58.             list.add(e);
  59.         }
  60.         return list;
  61.     }
  62. }
  64. public class SubOrder extends Order<Integer> {    // SubOrder:不是泛型类
  65. }
  66. public class SubOrder1<T> extends Order<T> {    // SubOrder1<T>:仍然是泛型类
  67. }
  1. @Test
  2. public void test1() {
  3.     // 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
  4.     // 要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型
  5.     Order order = new Order();
  6.     order.setOrderT(123);
  7.     order.setOrderT("ABC");
  9.     Order<String> order1 = new Order<String>("orderAA", 1001, "order:AA");
  10.     order1.setOrderT("AA:hello");
  11. }
  12. @Test
  13. public void test2() {
  14.     SubOrder sub = new SubOrder();
  15.     // 由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型
  16.     sub.setOrderT(1122);
  18.     SubOrder1<String> sub1 = new SubOrder1<>();
  19.     sub1.setOrderT("order1...");
  20. }

注意

  • 泛型类的构造器如下： public GenericClass() {}，public GenericClass{}是错误的
  • 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致

  • 泛型不同的引用不能相互赋值

    1. // 尽管在编译时 ArrayList<String>和ArrayList<Integer>是两种类型
    2. // 但是，在运行时只有一个ArrayList类被加载到JVM中
    3. @Test
    4. public void test3() {
    5.   Person p1 = null;
    6.   Person p2 = null;
    7.   p1 = p2;
    9.   ArrayList<String> list1 = null;
    10.   ArrayList<Integer> list2 = new ArrayList<Integer>();
    11.   // 泛型不同的引用不能相互赋值。
    12.   //        list1 = list2;
    13. }

  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object

    • 建议：泛型要使用一路都用。要不用一路都不要用
  • JDK1.7，泛型的简化操作： ArrayList first= new ArrayList<>();（类型推断）
  • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型 返回值类型。但在静态方法中不能使用类的泛型
  • 异常类不能是泛型的
  • 不能使用new E[]。但是可以：E[] elements = (E[]) new Object[capacity];
    • 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组
  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
    • 子类不保留父类的泛型：按需实现
      • 没有类型—-擦除
      • 具体类型
    • 子类保留父类的泛型：泛型子类
      • 全部保留
      • 部分保留
    • 结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型 ```java class Father { }

// 子类不保留父类的泛型 // 1)没有类型 擦除 class Son1 extends Father { // 等价于class Son extends Father{ }

// 2)具体类型 class Son2 extends Father { }

// 子类保留父类的泛型 // 1)全部保留 class Son3 extends Father { }

// 2)部分保留 class Son4 extends Father { }

  1. ```java
  2. class Father<T1, T2> {
  3. }
  5. /**
  6.  * 定义泛型子类Son
  7.  * 情况一：继承泛型父类后不保留父类的泛型
  8.  */
  9. // 1.没有指明类型  擦除
  10. class Son1<A, B> extends Father {    //等价于class Son1 extends Father<Object,Odject>{}
  11. }
  13. // 2.指定具体类型
  14. class Son2<A, B> extends Father<Integer, String> {
  15. }
  17. /**
  18.  * 定义泛型子类Son
  19.  * 情况二：继承泛型父类后保留泛型类型
  20.  */
  21. // 1.全部保留
  22. class Son3<T1, T2, A, B> extends Father<T1, T2> {
  23. }
  25. // 2.部分保留
  26. class Son4<T2, A, B> extends Father<Integer,T2> {
  27. }

自定义泛型方法

  • 方法也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型
  • 泛型方法的格式： **[访问权限] <泛型> 返回类型 方法名(泛型标识 参数名称) 抛出的异常 { }**
  • 泛型方法声明泛型时也可以指定上限 ```java // 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系 // 换句话说，泛型方法所属的类是不是泛型类都没有关系 // 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定 public static List copyFromArryToList(E[] arr) { ArrayList list = new ArrayList<>(); for (E e: list) {
    1.   list.add(e);
    } return list; }

@Test public void test4() { Order order = new Order<>(); Integer[] arr = new Integer[]{1,2,3,4};

  1. // 泛型方法在调用时，指明泛型参数的类型。
  2. List<Integer> list = order.copyFromArrayToList(arr);
  3. System.out.println(list);

}

  1. <a name="TFvwQ"></a>
  2. ### 泛型的应用场景
  3. DAO.java定：义了操作数据库中的表的通用操作。 ORM思想(数据库中的表和Java中的类对应)
  4. ```java
  5. public class DAO<T> {    // 表的共性操作的DAO
  7.     // 添加一条记录
  8.     public void add(T t){
  9.     }
  11.     // 删除一条记录
  12.     public boolean remove(int index){
  13.         return false;
  14.     }
  16.     // 修改一条记录
  17.     public void update(int index,T t){
  18.     }
  20.     // 查询一条记录
  21.     public T getIndex(int index){
  22.         return null;
  23.     }
  25.     // 查询多条记录
  26.     public List<T> getForList(int index){
  27.         return null;
  28.     }
  30.     // 泛型方法
  31.     // 举例：获取表中一共有多少条记录？获取最大的员工入职时间？
  32.     public <E> E getValue(){
  33.         return null;
  34.     }
  35. }

CustomerDAO.java

  1. public class CustomerDAO extends DAO<Customer>{    // 只能操作某一个表的DAO
  2. }

StudentDAO.java

  1. public class StudentDAO extends DAO<Student> {    // 只能操作某一个表的DAO
  2. }

DAOTest

  1. public class DAOTest {
  2.     @Test
  3.     public void test1() {
  4.         CustomerDAO dao1 = new CustomerDAO();
  5.         dao1.add(new Customer());
  6.         List<Customer> list = dao1.getForList(10);
  8.         StudentDAO dao2 = new StudentDAO();
  9.         Student student = dao2.getIndex(1);
  10.     }
  11. }

在继承上的体现

屏幕快照 2020-05-23 下午11.00.16.png
虽然类A是类B的父类，但是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.     // 编译不通过
  12.     //        Date date = new Date();
  13.     //        str = date;
  15.     List<Object> list1 = null;
  16.     List<String> list2 = new ArrayList<String>();
  17.     // 此时的list1和list2的类型不具有子父类关系
  18.     // 编译不通过
  19.     //        list1 = list2;
  21.     /*
  22.         反证法：
  23.             假设list1 = list2;
  24.             list1.add(123);导致混入非String的数据。出错。
  25.      */
  27.     show(list1);
  28.     show1(list2);
  29. }
  31. public void show(List<Object> list) {
  32. }
  34. public void show1(List<String> list) {
  35. }
  37. @Test
  38. public void test2(){
  39.     AbstractList<String> list1 = null;
  40.     List<String> list2 = null;
  41.     ArrayList<String> list3 = null;
  43.     list1 = list3;
  44.     list2 = list3;
  46.     List<String> list4 = new ArrayList<>();
  47. }

通配符

通配符的使用

  • 使用类型通配符：?
    • 比如：List<?>，Map<?, ?>
    • List<?>是List、List等各种泛型List的父类
      • 由于泛型Object与泛型String没有子父类关系，会导致要重载方法，而通配符可以解决这一继承问题
    • 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它都是Object
    • 不可以往list中写入元素，因为不知道元素类型，null除外
      • 将任意元素加入到其中不是类型安全的
        • Collection<?> c = new ArrayList();
        • c.add(new Object()); // 编译时错误
        • 因为我们不知道c的元素类型，add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个已知类型类或其子类，因为不知道那是什么类型，我们不能向其中添加对象
      • 唯一的例外的是null，它是所有类型的成员

    • 我们可以调用get()方法并使用其返回值，返回值是一个未知的类型，但我们知道它总是一个Object ```java public void test3() { List list1 = null; List list2 = null; List<?> list = null;

      list = list1; list = list2; // print(list1); // print(list2);

      List list3 = new ArrayList<>(); list3.add(“AA”); list3.add(“BB”); list3.add(“CC”); list = list3;

      // 添加(写入)：对于List<?>除了添加null之外,不能向其内部添加数据 // list.add(“DD”); // list.add(‘?’); list.add(null);

      // 获取(读取)：允许读取数据，读取的数据类型为Object Object o = list.get(0); System.out.println(o); }

      public void print(List<?> list) { Iterator<?> iterator = list.iterator(); while(iterator.hasNext()) { Object obj = iterator.next(); System.out.println(obj); } }

      1. **注意点**
      2. ```java
      3. // 🔴注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
      4. public static <?> void test(ArrayList<?> list){ 
      5. }
      7. // 🔴注意点2：编译错误：不能用在泛型类的声明上
      8. class GenericTypeClass<?> {    
      9. }
      11. // 🔴注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
      12. ArrayList<> list2 new ArrayList<?>();

      有限制的通配符

      • <?>：允许所有泛型的引用调用
      • 通配符指定上限
        上限extends：使用时指定的类型不能大于某个类，即<=
      • 通配符指定下限
        下限super：使用时指定的类型不能小于操作的类，即>=

      • 举例：

        • <? extends Number>只允许泛型为Number及Number子类的引用调用
        • <? super Number>只允许泛型为Number及Number父类的引用调用

        • <? extends Comparable>只允许泛型为实现 Comparable接口的实现类的引用调用

          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. // 编译不通过
          31. //        list1.add(new Student());
          33. // 编译通过
          34. list2.add(new Person());
          35. list2.add(new Student());
          36. }

      举例

      1. public class DAO<T> {
      2.     private Map<String, T> map = new HashMap<String, T>();
      4.     // 保存 T 类型的对象到 Map 成员变量中
      5.     public void save(String id, T entity) {
      6.         map.put(id, entity);
      7.     }
      9.     // 从 map 中获取 id 对应的对象
      10.     public T get(String id) {
      11.         return map.get(id);
      12.     }
      14.     // 替换 map 中key为id的内容，改为 entity 对象
      15.     public void update(String id, T entity) {
      16.         if (map.containsKey(id)) {
      17.             map.put(id, entity);
      18.         }
      19.     }
      21.     // 返回 map 中存放的所有 T 对象
      22.     public List<T> list() {
      23.         // 错误的：
      24.         //        Collection<T> values = map.values();
      25.         //        return (List<T>) values;
      26.         // 正确的：
      27.         ArrayList<T> list = new ArrayList<>();
      28.         Collection<T> values = map.values();
      29.         for (T t : values) {
      30.             list.add(t);
      31.         }
      32.         return list;
      33.     }
      35.     // 删除指定 id 对象
      36.     public void delete(String id) {
      37.         map.remove(id);
      38.     }
      39. }
      1. public class DAOTest {
      2.     public static void main(String[] args) {
      3.         DAO<User> dao = new DAO<>();
      5.         dao.save("1001", new User(1001, 34, "周杰伦"));
      6.         dao.save("1002", new User(1002, 20, "昆凌"));
      7.         dao.save("1003", new User(1003, 25, "蔡依林"));
      9.         dao.update("1003", new User(1003, 30, "方文山"));
      11.         dao.delete("1002");
      13.         List<User> list = dao.list();
      14.         //        System.out.println(list);
      15.         list.forEach(System.out::println);
      16.     }
      17. }

      泛型应用举例