泛型

• 泛型
  • 前言
  • 1. 泛型概述
    • 1.1 泛型的使用
    • 1.2 泛型的嵌套
  • 2. 自定义泛型
    • 2.1 自定义泛型类/接口
      • 2.1.1 泛型的继承
      • 2.1.2 注意事项
    • 2.2 自定义泛型方法
    • 2.3 通配符("?")

前言

本文为B站Java教学视频BV1Kb411W75N的相关笔记，主要用于个人记录与分享，如有错误欢迎留言指出。
本章笔记涵盖视频内容P562~P580

1. 泛型概述

• 定义：泛型就是允许在定义类或接口时，通过一个标识，表示类中某个属性的类型或某个方法的返回值及参数类型。这个类型参数在被使用的时候（如继承或实现接口，用这个类型声明变量，创建对象）才会确定

1.1 泛型的使用

• 在实例化集合类时，可以指定具体的泛型类型。指明之后，在集合类或接口中，凡是定义类或接口时，内部结构（如：方法，构造器，属性）使用到类的泛型的位置，都会指定为实例化的泛型类型。

//设计一种场景，定义一种集合，并用指定泛型限制添加的元素，最后遍历集合中的元素
public void test2(){
    //指定泛型为Integer这样ArrayList只会接收类型为Integer的参数
    ArrayList<Integer> list = new ArrayList<Integer>();
    
    list.add(78);
    list.add(66);
    list.add(55);
    list.add("Tom");	//不符合泛型类型，报错
    
    //方式一:
    for(Integer score : list){
        //这样遍历的时候就不用检查obj类型(obj instanceof Integer)
        //也不用强转类型((Integer)obj)
        int stuScore = score;	//自动拆箱
        System.out.println(stuScore);
    }
    
    //方式二:
    //迭代器也可以指定泛型,这样迭代器就只能遍历Integer类型,遇到其它类型会报错
    Iterator<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        int stuScore = iterator.next();
        System.out.println(stuScore);
    }
}

1.2 泛型的嵌套

public void test3(){
    //Map类型由于有两个参数，所以要指定两个泛型
    Map<String,Integer> map = new HashMap<>();
    
    map.put("Tom",87);
    map.put("Jerry",54);
    map.put("Jack",78);
    
    //Set需要用到Map的Entry数组，此处对Entry数组指定泛型后，将Set的泛型指定为这种泛型的Entry数组
    Set<Map.Entry<String,Integer>> entry = map.entrySet();
    Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
    
    while(iterator.hasNext()){
        Map.Entry<String,Integer> e = iterator.next();
        String key = e.getKey();
        Integer value = e.getValue();
        System.out.println(key + "-----" + value);
    }
}

2. 自定义泛型

• 自定义泛型结构分为：泛型类，泛型接口，泛型方法

2.1 自定义泛型类/接口

public class Order<T>{
    
    String orderName;
    T orderT;	//类的内部结构可以使用类的泛型
    
    public Order(){
        
    };
    
    public Order(String orderName,int orderId,T orderT){
            this.orderName = orderName;
            this.orderT = orderT;
    }
    
    public T getOrderT(){
        return orderT;
    }
    
    public void setOrderT(T orderT){
        this.orderT = orderT;
    }
}

/*
自定义泛型接口与自定义泛型类相似，此处省略
*/

2.1.1 泛型的继承

• 使用extends定义子类时的继承关系

//方式一:子类直接继承了父类的某一种指定泛型
public class SubOrder extends Order<Integer>{
    //此时实例化此子类对象时,不需要在指明泛型,默认为继承的指定的泛型
}

//方式二:子类整个的继承了父类的泛型
public class SubOrder1<T> extends Order<T> {
    //此时此子类仍然是泛型类,在实例化时仍需要指明泛型类型
}

/*
以上是两种较为常见的书写方式，下面展示了所有可能的继承情况
*/

class Father<T1,T2>{}
//子类不保留父类的泛型
	//1)没有类型 擦除
	class Son1 extends Father{};//等价于class Son1 extends Father<Object,Object>
	class Son1_<A,B> extends Father{};//Son1抛弃父类所有泛型,并自创了两个泛型
	//2)具体类型
	class Son2 extends Father<Integer,String>{};
	class Son2_<A,B> extends Father<Integer,String>{};
//子类保留父类的泛型
	//1)全部保留
	class Son3<T1,T2> extends Father<T1,T2>{};
	class Son3_<T1,T2,A,B> extends Father<T1,T2>{};//Son3保留父类所有泛型,且自创了两个泛型
	//2)部分保留
	class Son4<T2> extends Father<Integer,T2>{};
	class Son4_<T2,A,B> extends Father<Integer,T2>{};

• 子父类实例化后的继承关系

//虽然类A是类B的父类，但G<A>个G<B>两者不具备子父类关系，两者是并列关系
List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
list1 = list2;	//报错，无法赋值

//类A是类B的父类，A<G>和B<G>是子父类关系
AbstractList<String> list1_ = null;
List<String> list2_ = null;
ArrayList<String> list3 = null;
list1_ = list3;
list2_ = list3;	//赋值成功

2.1.2 注意事项

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如<E1,E2,E3>

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

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

• 如果泛型类是一个接口或抽象类，则不可创建泛型类的对象

• 泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

• 泛型的简化操作：ArrayList flist = new ArrayList<>();

• 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型，非静态方法的参数类型，非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

• 异常类不能是泛型的

• 创建一个泛型数组 E[] elements = (E[])new Object[capacity];

2.2 自定义泛型方法

• 定义：在方法中出现了泛型的结构，且泛型参数与类的泛型参数没有任何关系

  ​ （泛型方法所属的类是不是泛型类都没有关系）

  public <E> List<E> copyFromArrayToList(E[] arr){
      
      ArrayList<E> list = new ArrayList<>();
      
      for(E e : arr){
          list.add(e);
      }
      return list;
  }
  
  public void test4(){
      Order<String> order = new Order<>();
      Integer[] arr = new Integer[]{1,2,3,4};
      //泛型方法在调用时，指明泛型参数的类型
      List<Integer> list = order.copyFromArrayToList(arr);
      
      System.out.println(list);
  }
  
  /*
  注意：泛型方法可以声明为静态。因为泛型参数是在调用方法时确定的，并非在实例化类时确定
  */
  

2.3 通配符("?")

• 定义：为了解决子父类实例化后的继承关系 的问题，引入了通配符；使用通配符实例化的对象，可以接收任意泛型类型的对象

  //类A是类B的父类,G<A>和G<B>是没有关系的，二者的共同父类是:G<?>
  public void test3(){
      List<Object> list1 = null;
      List<String> list2 = null;
      
      list1 = list;
      list2 = list;
      
      print(list1);
      print(list2);
  }
  public void print(List<?> list){
          Iterator<?> iterator = list.iterator();
          while(iterator.hasNext()){
              Object obj = iterator.next();	//由于类型不确定,所以安全起见用Object接收
              System.out.println(obj);
          }
  }
  /*
  注意:
  1.对于List<?>,除了添加null之外,对于List<?>就不能向其内部添加数据
  2.List<?>允许读取数据，读取的数据类型为Object
  */
  

• 有限制条件的通配符的使用

  //<? extends Number>:只允许泛型为Number及Number子类的引用调用
  //<? super Number>:只允许泛型为Number及Number父类的引用调用
  
  List<? extends Person> list1 = null;
  List<? super Person> list2 = null;
  
  List<Student> list3 = null;
  List<Person> list4 = null;
  List<Object> list5 = null;
  
  list1 = list3;
  list1 = list4;
  list1 = list5;//报错,无法添加比Person更大的类型
  
  list2 = list3;//报错,无法添加比Person更小的类型
  list2 = list4;
  list2 = list5;
  
  /*
  有限制条件的通配符与一般通配符的读取操作一样,只是不能读取为比限制更小/更大的数据类型
  有限制条件的通配符允许写入数据,只要满足限制即可
  */