1、泛型-介绍

为什么需要泛型

使用泛型，使得程序具有更好的可读性和安全性。

没有泛型之前，集合使用的是Object，导致一个集合里可能出现不同类型的数据，比如String，File等，导致其他人都不知道这个集合中有哪些类型数据。add()方法的时候，编译和运行都不会出错，但是在get()获取结果的时候，需要强制类型转换成需要的类型，这时可能会出现类型转换异常。
使用泛型后，ArrayList<String>(String为类型参数/类型变量)，可以很明确这个数据的类型都是String，添加其他类型，编译就会报错。而且有很好的安全性，类型单一，不需要类型转换。

类型变量说明

类型变量使用大写形式，且比较短，使用变量 E 表示集合的元素类型， K 和 V 分别表示表的关键字与值的类型。T ( 需要时还可以用临近的 字 母 U 和 S )表示“ 任意类型 ”。

泛型类

public class Pair<T> {
    private T first;
    private T second;

    public Pair() {
        first=null;
        second=null;
    }

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }
}

Pair类引入了一个类型变量T，用尖括号（<>）括起来，并放在类名后面，泛型类可以有多个类型变量，比如，可以定义Pair类，其中第一个域和第二个域使用不同的类型： public class Pair<T,U>{...}
类定义中的类型变量指定方法的返回类型以及域和局部变量的类型，比如： private T first;

泛型方法

public class ArrayAlg {
    public static <T> T getMiddle(T... a) {
        return a[a.length / 2];
    }
}

类型变量放在修饰符（如public static）的后面，返回类型的前面。返回类型可以不为T，<T>只是对入参类型的说明
泛型方法可以定义在普通类中，也可以定义在泛型类中。
调用泛型方法，ArrayAlg.getMiddle("john","q","public");
编译器能自动推断出T的类型，如果入参类型不一致，编译器会寻找这些类型的共同超类，返回类型就是这个超类型，如果有多个超类，赋值给哪一个超类型都可以。Object是所有的超类，所以不会报错。

泛型接口

public interface Generator<T> {
    public T next();
}

类型变量的限定

public class ArrayAlg {
    public static <T> T min(T[] a) {
        if (a == null || a.length == 0) {
            return null;
        }
        T smallest = a[0];
        for (int i = 1; i < a.length; i++) {
            if (smallest.compareTo(a[i]) > 0) {
                smallest = a[i];
            }
        }
        return smallest;
    }
}

这里有一个问题。请看一下min方法的代码内部。变量smallest类型为T,这意味着它可以是任何一个类的对象。怎么才能确信 T 所属的类有compareTo方法呢?解决这个问题的方案是将 T 限制为实现了 Comparable 接口 (只含一个方法 compareTo 的 标准接口)的类。可以通过对类型变量 T 设置限定 实现这一点:public static <T extends Comparable> T a) {...}
现在，泛型的 min 方法只能被实现了 Comparable 接口的类(如 String、 LocalDate 等)的数 组调用。没有实现 Comparable 接口，调用 min 将会产生一个编译错误。

为什么使用关键字extends而不是implements呢，毕竟Comparable是一个接口<T extends BoundingType> 表示T应该是绑定类型的子类型，T和绑定类型可以是类，也可以是接口，选择关键字extends的原因是更接近子类的概念，并且java设计者也不打算在语言中再添加一个新的关键字。

一个类型变量或通配符可以有多个限定，比如：T extends Comparable & Serializable，表示T必须同时是Comparable和Serializable的子类。如果限定的不是接口，它必须放在限定列表的第一个位置，如T extends BaseReq & Serializable，BaseReq放在后面就会报错。

限定类型用“&”分隔，类型变量用“,”分隔，如（K,V）。