一、泛型概述

泛型（generics）的本质是参数化类型，也就是说所有操作的数据类型被指定为一个参数。这种参数类型可用于类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

二、为什么需要泛型

没有泛型的情况下，通过对类型Object的引用来实现参数的“任意化”，"任意化"带来的缺点是要做显示的强制类型转换，而这种转换要求开发者对实际参数类型可以预知的情况下进行。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

    @Testpublic void test(){List list = new ArrayList();list.add("string");list.add(100);`	for (int i = 0; i < list.size(); i++) {String item = (String) list.get(i);System.out.println("item is : " + item);}}
result:
item is : string
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList可以存放任意类型（Object），例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

        List<String> list1 = new ArrayList<>();list1.add("String");list1.add(100); //在编译阶段，编译器就会报错

三、泛型存在阶段

泛型只在编译阶段有效

    @Testpublic void test1(){List<String> stringList = new ArrayList<>();List<Integer> integerList = new ArrayList<>();System.out.println(stringList.getClass()); //class java.util.ArrayListSystem.out.println(integerList.getClass()); // class java.util.ArrayListSystem.out.println(stringList.getClass().equals(integerList.getClass())); //true}

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出。
对此总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

四、泛型的使用

泛型有三种使用方式：泛型类、泛型接口、泛型方法。
对于常见的泛型模式，推荐的名称是：
K ——键，比如映射的键。
V ——值，比如 List 和 Set 的内容，或者 Map 中的值。
E ——异常类。
T ——泛型。

1. 泛型类

泛型类型用于类的定义中，被称为泛型类。最典型的就是各种容器类，如：List、Set、Map。

//在实例化泛型类时，必须指定T的具体类型
public class Generics<T> {//key这个成员变量的类型为T,T的类型由外部指定private T key;public Generics(T key) {this.key = key;}public T getKey() {return key;}public void setKey(T key) {this.key = key;}
}

泛型的类型参数只能是类类型（包括自定义类），不能是简单类型

    @Testpublic void test2(){Generics<Integer> integerGenerics = new Generics<>(123);System.out.println(integerGenerics.getKey()); //123System.out.println(integerGenerics.getKey().getClass().getName()); //java.lang.Integer}

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

        Generics any = new Generics<>(123);System.out.println(any.getKey());System.out.println(any.getKey().getClass().getName()); //java.lang.Integer

2. 泛型接口

泛型接口的定义

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

泛型接口的实现的类，未传入参类型：

/**未传入泛型实参时：*与泛型类的定义相同，在声明类的时候，需要将泛型的声明也一起加到类中*即GeneratorChild<T>要声明<T>*/
public class GeneratorChild<T> implements Generator<T>{@Overridepublic T next() {return null;}
}

泛型接口的实现的类，传入参类型：

/*** 传入泛型实参时：* 定义一个生产器实现接口，虽然我们只创建了一个泛型接口Generator<T>,但是我们可以为T传入无数个实参，形成无数种类型的Generator接口* 在实现类实现泛型接口时，如已经将泛型类型传入实参类型，则所有泛型的地方都要替换成传入的实参类型* 即Generator<T>和public T next();中的T都要替换成传入的String类型*/
public class GeneratorChild1 implements Generator<String> {@Overridepublic String next() {return null;}
}

3. 泛型方法

假设需要实现这样一个方法：该方法负责将一个Object数组的所有元素添加到Collection集合中。考虑采用如下代码实现该方法：

    public void formArrayToCollention(Object[] obj, Collection<Object> col){for(Object o:obj){col.add(o);}}@Testpublic void test4(){String[] strArr = {"a", "b"};List<String> strList = new ArrayList<>();formArrayToCollention(strArr,strList); //编译报错，Collection<String>不能当成Collection<Object>使用}

因为Collection< String>不是Collection< Object>的子类型，所以这一方法功能有限。它只能将Object[] 数组的元素复制到元素为Object(Object的子类都不行)的Collection的集合中。
可见方法formArrayToCollention的参数类型不可为Collection，使用统配符Collection<?>也不行，因为Java不允许把对象放进一个位置类型的集合里。
为解决这个问题，可以使用Java5提供的泛型方法，在声明方法时定义一个或者多个类型形参。泛型用法格式如下：

修饰符 <T, S> 返回值类型 方法名(形参列表){//方法体...
}

该分型方法的方法签名比普通方法的方法签名多了类型形参声明，类型形参声明义尖括号括起来，多个类型形参之间以逗号隔。所有的类型形参声明放在方法修饰符和返回值类型之间。

采用泛型方法，可以将上面的formArrayToCollention方法改写为：

    //声明一个泛型方法，该泛型方法中带一个T类型形参public <T> void formArrayToCollention(T[] obj, Collection<T> col){for(T o:obj){col.add(o);System.out.println("adding: " + o);}}

以下是完整用法：

    //声明一个泛型方法，该泛型方法中带一个T类型形参public <T> void formArrayToCollention(T[] obj, Collection<T> col){for(T o:obj){col.add(o);System.out.println("adding: " + o);}}@Testpublic void test4(){String[] strArr = {"a", "b"};Collection<String> strList = new ArrayList<>();formArrayToCollention(strArr,strList); //T代表String类型Integer[] intArr = {1, 2};Collection<Number> numList = new ArrayList<>();formArrayToCollention(intArr,numList); //T代表Number类型}

上面的程序调用了一个泛型方法，该泛型方法中定义了一个T类型形参，这个T类型形参就可以在该方法内当成普通类型使用。与接口、类中定义的类型参数不同的是，方法声明中定义的形参只能在该方法内使用，而接口、类声明中定义的类型形参则可以在整个接口、类中使用。
与接口、类中泛型参数不同的是，方法中的泛型参数无需显式传入实际类型参数，编译器根据实参推断类型实参的值。

在下面程序中:

public class ErrorTest {//声明一个泛型方法，该泛型方法中带一个T类型形参static <T> void fromCollectionToCollection(Collection<T> from, Collection<T> to){for(T f:from){to.add(f);}}@Testpublic void test(){List<Object> to = new ArrayList<>();List<String> from = new ArrayList<>();fromCollectionToCollection(from, to);/*** fromCollectionToCollection (java.util.Collection<T>, java.util.Collection<T>)* in ErrorTest cannot be applied* to(java.util.List<java.lang.String>, java.util.List<java.lang.Object>)*  *  reason: Incompatible equality constraint: Object and String*/}
}

在上面程序中定义了fromCollectionToCollection的方法中，两个形参类型都是Collection，这要求调用该方法时的两个集合是惨重的泛型类型完全一致，否则编译器无法准确推断出泛型方法中类型形参的类型。
为避免此类错误，可将方法改为：

public class ErrorTest {//声明一个泛型方法，该泛型方法中带一个T类型形参static <T> void fromCollectionToCollection(Collection<? extends T> from, Collection<T> to){for(T f:from){to.add(f);}}@Testpublic void test(){List<Object> to = new ArrayList<>();List<String> from = new ArrayList<>();fromCollectionToCollection(from, to);//代码正常运行}
}

上面代码改变了fromCollectionToCollection方法的签名，将该方法的前一个形参改为Collection<? extends T>，这种采用类型统配符的表达方式，值要fromCollectionToCollection方法的前一个Collection集合里的元素类型时后一个Collection集合里元素类型的子类即可。

五、泛型通配符

我们知道Ingeter是Number的一个子类，同时也验证过Generic< Integer> 与Generic< Number>实际上是同一种类型， 那么在使用Generic< Number>作为形参的方法中，能否使用Generic< Ingeter>的实例传入呢？
为了弄清楚这个问题，我们使用Generic< T>这个泛型类继续看下面的例子：

    public void TestGeneric(Generics<Number> obj){System.out.println("generics test " + obj.getKey());}@Testpublic void test3(){Generics<Integer> gi = new Generics<>(123);Generics<Number> gn = new Generics<>(123);TestGeneric(gi); //编译报错: TestGeneric (com.learning.generics.Generics<java.lang.Number>)//in GenericsTest cannot be applied to (com.learning.generics.Generics<java.lang.Integer>)}

通过错误信息可知：同一泛型类可以对应多个类型，不同类型的泛型类实例是不兼容的
那怎么解决上面的问题呢？总不能为了定义一个新方法来处理Generics< Integer>， 这显然不合理。因此我们需要一个逻辑上可以表示Generic< Integer>和Generic< Number>父类的引用类型。由此类型通配符应运而生。
我们可以将方法改为:

    public void TestGeneric(Generics<?> obj){System.out.println("generics test " + obj.getKey());}

统配符一般使用？替代具体的类型参数，注意：此处的“？”是类型实参而不是类型形参。再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体了类型不确定且操作时不需要知道具体类型的场景中。

六、泛型方法和类统配符的区别

大多数时候都可以使用泛型方法来代替类型统配符。例如，对于Java的Collection接口中两个方法定义：

public interface Collection<E> extends Iterable<E> {boolean containsAll(Collection<?> c);boolean addAll(Collection<? extends E> c);...
}

上面集合中两个方法的形参都采用了类型通配符的形式，也可以采用泛型方法的形式，如下所示：

public interface Collection<E> extends Iterable<E> {<T> boolean containsAll(Collection<T> c);<T extends E> boolean addAll(Collection<T> c);...
}

上面方法使用了泛型形式，这是定义类型形参时设定上限（其中E是Collection接口里定义的类型形参，在该接口里E可以当成普通类型使用）
上面两个方法中类型形参T只使用了一次，类型形参T产生的唯一效果是可以在不同的调用点传入不同的实际类型。对于这种情况，应该使用通配符。通配符就是被设计用来支持灵活的子类化的。
泛型方法允许类型形参被用来表示方法的一个或多个参数之间的依赖关系，或者方法返回值与参数之间的类型依赖关系。如果没有这样的类型依赖关系，就不应该使用泛型方法。
如果某一个方法中一个形参（a）的类型或返回值的类型依赖于另一个形参（b）的类型，则形参（b）的类型声明不应该使用通配符----因为形参（a）或则返回值的类型依赖于该形参（b）的类型，如果形参（b）的类型无法确定，程序就无法定义形参（a）的类型，在这种情况下，只能考虑使用在方法签名中声明类型形参----也就是泛型方法。
如果有需要，也可以同时使用泛型方法和通配符，如Java的Collections.copy()方法

public class Collections {public static <T> void copy(List<? super T> dest, List<? extends T> src) {...
)

参考：
https://blog.csdn.net/caihuangshi/article/details/51278793
https://blog.csdn.net/s10461/article/details/53941091
https://blog.csdn.net/weixin_43819113/article/details/91042598