泛型 | Java自学笔记

为什么要有泛型

泛型的概念

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

在集合中使用泛型

• 集合接口或集合类在JDK5.0时都修改为带泛型的结构；在实例化集合类时，可以指明具体的泛型类型；指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（如方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型，比如add(E e) —→实例化以后：add(Integer e)

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

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

  public class GenericTest {
  
      //在集合中使用泛型之前的情况
      @Test
      public void test1(){
          ArrayList list = new ArrayList();
          //需求：存放学生成绩
          list.add(78);
          list.add(76);
          list.add(89);
          list.add(88);
          //问题一：类型不安全
          //list.add("Tom");
  
          for(Object score : list){
              //问题二：强转时可能出现ClassCastException
              int stuScore = (int) score;
              System.out.println(stuScore);
  
          }
  
      }
  
      //在集合中使用泛型的情况
      @Test
      public void test2(){
          ArrayList<Integer> list = new ArrayList<Integer>();
  
          list.add(78);
          list.add(65);
          list.add(43);
          list.add(87);
  
          //编译时进行类型检查
          //list.add("Tom");
          //方式一
  //        for(Integer score : list){
  //            //避免了强转操作
  //            int stuScore = score;
  //            System.out.println(score);
  //        }
          //方式二：
          Iterator<Integer> iterator = list.iterator();
          while(iterator.hasNext()){
              int stuScore = iterator.next();
              System.out.println(stuScore);
          }
      }
  
      //在集合中使用泛型的情况：以HashMap为例
      @Test
      public void test3(){
          Map<String, Integer> map = new HashMap<>();
  
          map.put("Tom", 89);
          map.put("Curry", 89);
          map.put("James", 89);
  
          Set<Map.Entry<String, Integer>> entries = map.entrySet();
          Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
  
          while(iterator.hasNext()){
              Map.Entry<String, Integer> entry = iterator.next();
              String key = entry.getKey();
              Integer value = entry.getValue();
              System.out.println(key + "----" + value);
          }
      }
  
  }
  

自定义泛型结构

泛型类、泛型接口

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内

• 泛型类的构造器如下：public GenericClass(){}，注意没有泛型

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

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

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

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

• JDK1.7，泛型的简化操作：ArrayListflist = new ArrayList<>();

• 泛型的指定中不能使用基本数据类型，可以使用包装类替换

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

• 异常类不能是泛型的

• 不能使用new E[]，但是可以：E[] elements = (E[])new Object[capacity];

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

  • 子类不保留父类的泛型：按需实现

    • 没有类型 擦除
    • 具体类型

  • 子类保留父类的泛型：泛型子类

    • 全部保留
    • 部分保留

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

泛型方法

• 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，或者说，反省方法所述的类是不是泛型类都没有关系

//泛型方法可以声明为静态的，因为泛型参数是在调用方法时确定的并非在实例化类时确定的
public static <E> List<E> copyFromArrayToList(E[] arr){
		ArrayList<E> list = new ArrayList<>();
		for (E e : arr){
				list.add(e);
		}
		return list;
}

//测试泛型方法
@Test
public void test4(){
    Order<String> order = new Order<>();
    Integer[] arr = new Integer[]{1,2,3,4};
		//泛型方法在调用时，指明泛型参数的类型
    List<Integer> list = copyFromArrayToList(arr);
    System.out.println(list);
}

泛型在继承上的体现

• 类A是类B的父类，G和G二者不具备子父类关系，二者是并列关系