1. 泛型基础

1.1 为什么要有泛型

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK 1.5 之前只能把元素类型设计为 Object，JDK 5.0 之后使用泛型来解决。因为这个时候除了元素的类型不能确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此把元素类型设计成一个参数，这个类型参数就叫做泛型。Collection，List，ArrayList 这个E就是类型参数，即泛型。虽然，集合相较于数组的一大优点就是集合元素类型是可以随意存放、互不相同、没有限制的，但正是因为这种没有限制，导致集合元素间的管理就较为复杂，因此引入泛型来严格化集合的管理。
可以把泛型理解为一种标签，就像中药店里每个抽屉外都会贴着标签来标识这个抽屉放的是什么类型的药。再举个例子，就是生活中的垃圾分类，不加泛型的集合就像把所有垃圾放在一起，最后会不好处理，加了泛型的集合就像是用标签对垃圾做了分类，处理起来更高效。

1.2 泛型概念

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

2. 使用泛型

用 <> 表示使用到了泛型，要注意，泛型中的元素类型只能是类，不能是基本数据类型。使用格式为：

public class GenericTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
    }
}

当对集合用泛型做了规范后，就只能向集合中添加指定元素类型的对象：

如果直接添加其他类型的对象，编译时就会直接报错：

由于元素类型都统一了，因此 foreach 遍历时就不再需要 Object 类型了，拿上例来说，直接用 Integer 就行

public class GenericTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(123) ;
        list.add(345) ;
        for (Integer integer : list){
            int num = integer ; // 自动拆箱，避免了强转操作
            System.out.println(num);  // 123 /n 345
        } 
    }
}

再看一下 Map 使用泛型。Map 由于存储的键值对是两个对象，因此泛型要对两个元素类型都做出规范：

使用时也要如此声明：

Map<String,String> map = new HashMap<>() ;

在遍历时，接受 keySet、Values、entrySet 方法返回值的集合类型也要被泛型规范。这样在 foreach中就可以用具体类型来替代 Object 了。

public class GenericTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>() ;
        map.put("abc","hhh");
        map.put("bcd","lll");

        Set<String> set = map.keySet();
        for (String str :set){
            System.out.println(str+"==="+map.get(str));
        }
    }
}

同样，迭代器 Iterator 也要用泛型规范化：

public class GenericTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>() ;
        map.put("abc","hhh");
        map.put("bcd","lll");

        Set<String> set = map.keySet();
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str+"==="+map.get(str));
        }
    }
}

实际上，编写上述代码时，使用 Alt + Enter 建进行自动补全，IDEA 均会将接受返回值的元素类型继续泛型规范化。

3. 自定义泛型结构

3.1 泛型类

public class Order<T> {
    private String orderName;
    private int orderId ;
    // 类的内部可以使用泛型参数 T
    T orderT ;

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public String getOrderName() {
        return orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

在一般的类中，属性的类型都是确定的，如 orderName 和 orderId 的属性分别确定为 String 和 int。但是，有时候，我们定义一个类时不能确定某一个属性的类型，它取决于调用者，因此才会使用到泛型，这样的类称作泛型类。
上述代码中，T 是一个类型参数，类内部可以认为 T 就是一个类的类型，而调用者就可以通过传参 T 来决定 orderT 的实际类型。
当调用Order类时，如果不指定参数T，会默认T是Object。

所以一旦用了泛型，后续操作都要指定类型，包括集合。应该在左侧 Order 后用 <> 来进行泛型规范，正确的写法应该是：

public class GenericTest {
    public static void main(String[] args) {
        Order<String> order = new Order("apple",123,"desc") ;
    }
}

之后，调用 setOrder 就只能传 String 型了。也就是说，当构造时指定了类型，T 就确定了，无法更改

当定义完泛型类后，如果有子类要继承该父类，则在声明可以在父类后指明类型，否则默认 Object：

public class SubOrder extends Order<Integer> {
    public SubOrder(String orderName, int orderId, Integer orderT) {
        super(orderName, orderId, orderT);
    }
}

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
当然，很多时候父类之所以要用到泛型是因为该类型无法确定，所在子类继承泛型父类时也无法确定指定类型，仍然需要调用者来决定，这时，子类就要保留父类的泛型。

【正确写法】

public class SubOrder<T> extends Order<T> {
    public SubOrder(String orderName, int orderId, T orderT) {
        super(orderName, orderId, orderT);
    }
}

【错误写法】

3.2 泛型接口

自定义泛型接口和自定义泛型类的格式是一样的，他们之间的使用区别就是类和接口之间的区别，和泛型无关。泛型在接口中的作用就是用来供调用者指定接口中抽象方法的返回值：

public interface USB<T> {
    T start();
    T stop();
    // 注意，start 和 stop 不是泛型方法。
}

然后实现泛型接口的类也要保留该泛型：

public class Printer<T> implements USB<T>{
    @Override
    public T start() {
        return null;
    }

    @Override
    public T stop() {
        return null;
    }
}

【总结：泛型类和泛型接口的注意点】

泛型类可能有多个参数，此时要将多个参数一起放在尖括号内。比如：
类内部可以直接使用 T，因此构造器的声明不再需要尖括号<>
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
泛型不同的引用不能相互赋值
泛型如果不指定，将被擦除，泛型对应的类型均按照 Object 处理，但不等价于 Object。所以：
- 泛型要使用就一路都用，要不使用就一路都不用。
如果泛型类是一个接口或抽象类，则不可创建泛型类的对象。
泛型的简化操作：ArrayList flist = new ArrayList<>();
泛型的指定中不能使用基本数据类型，可以使用包装类替换

3.3 泛型方法
在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。
下面代码所述的方法可以将对象数组转换为ArrayList，但是具体元素类型不确定，所以使用泛型。
```
public <E> List<E> copyFromArrayToList(E[] arr){
  ArrayList<E> list = new ArrayList<>();

  for (E e : arr){
      list.add(e);
  }
  return list;
}
```
第一个是一个标识，它的作用是高速编译器这里的方法使用到了泛型，没有则会报错
第二个供调用者指定返回 List 中的元素类型
第三个 E 供调用者指定入参数组的元素类型。

调用泛型方法时，要指明泛型参数的类型：

public static void main(String[] args) {
    GenericTest test = new GenericTest();
    Integer[] ints = new Integer[]{1,2,3,4};
    List<Integer> integers = test.copyFromArrayToList(ints);
    for (Integer id : integers){
        System.out.println(id);
    }
}

另外，泛型方法是可以声明为静态的，这是因为泛型参数是在调用方法时指定的，而不是在实例化时指定的。

4. 泛型在继承上的体现

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

泛型