前言
置信大家对Java泛型并不生疏，无论是开源框架还是JDK源码都能看到它，毫不夸大的说，泛型是通用设计上必不可少的元素，所以真正了解与正确应用泛型，是一门必修课，本文将解开大家对泛型的纳闷，并通过大量实际，让你get到泛型正确的应用姿态，上面开始进入正题吧！
纲要
根底
因为本文重实际，而且面对的是Java开发人员群体，大家对泛型都有根底，所以泛型根底这块会疾速过，帮忙大家回顾下即可，前面次要的则重点是通配符
编译期与运行期
编译期是指把源码交给编译器编译成计算机可执行文件的过程，运行期是指把编译后的文件交给计算机执行，直到程序完结。
在Java中就是把.java文件编译成.class文件，再把编译后的文件交给J V M加载执行，如下图
泛型
泛型又叫“参数化类型”，这么形象的业余词汇不好了解，阿星就用大白话的模式来解释。
人是铁，饭是刚，吃饭是刚需，要吃饭天然就少不了碗筷，然而没有规定碗只能盛饭，除了盛饭它还能盛汤、盛菜，制造者只造这个碗，不关怀碗盛什么，具体要盛什么由使用者来决定，这就是泛型的概念。
泛型就是在定义类、接口、办法的时候指定某一种特定类型（碗），让类、接口、办法的使用者来决定具体用哪一种类型的参数（盛的货色）。
Java的泛型是在1.5引入的，只在编译期做泛型查看，运行期泛型就会隐没，咱们把这称为“泛型擦除”，最终类型都会变成 Object。
在没有泛型之前，从汇合中读取到的每一个对象都必须进行类型转换，如果不小心插入了谬误的类型对象，在运行时的转换解决就会出错，有了泛型后，你能够通知编译器每个汇合接管的对象类型是什么，编译器在编译期就会做类型查看，告知是否插入了谬误类型的对象，使得程序更加平安，也更加分明。
最初插一句，泛型擦除与原生态类型（List就是原生态，List<T>非原生态）是为了关照1.5以前设计上的缺点，为兼容非泛型代码，所作出的折中策略，所以不举荐应用原生态类型，如果应用了原生态类型，就失去了泛型在安全性与描述性方面的劣势。
泛型类
类上定义泛型，作用于类的成员变量与函数，代码实例如下
public class GenericClass<T>{ //成员变量 private T t; public void function(T t){ } public T functionTwo(T t){ //留神，这个不是泛型办法！！！ return t; }}泛型接口
接口上定义泛型，作用于函数，代码实例如下
public interface GenericInterface<T> { public T get(); public void set(T t); public T delete(T t); default T defaultFunction(T t){ return t; }}泛型函数
函数返回类型旁加上泛型，作用于函数，代码实例如下
public class GenericFunction { public <T> void function(T t) { } public <T> T functionTwo(T t) { return t; } public <T> String functionThree(T t) { return ""; }}通配符
通配符是为了让Java泛型反对范畴限定，这样使得泛型的灵活性晋升，同时也让通用性设计有了更多的空间。
<?>：无界通配符，即类型不确定，任意类型<? extends T>：上边界通配符，即?是继承自T的任意子类型，恪守只读不写<? super T>：下边界通配符，即?是T的任意父类型，恪守只写不读
置信大部分人，都是倒在通配符这块，这里多唠叨点，「通配符限定的范畴是体现在确认“参数化类型”的时候，而不是“参数化类型”填充后」，可能这句话不太好了解，来看看上面的代码
/** * 1.创立泛型为Number的List类，Integer、Double、Long等都是Number的子类 * new ArrayList<>() 等价于 new ArrayList<Number>() */List<Number> numberList = new ArrayList<Number>();/** * 2.增加不同子类 */numberList.add(1);//增加Integer类型numberList.add(0.5);//增加Double类型numberList.add(10000L);//增加Long类型/** * 3.创立泛型为Number的List类，Integer、Double、Long等都是Number的子类 * 援用是泛型类别是Number，但具体实现指定的泛型是Integer */List<Number> numberListTwo = new ArrayList<Integer>();//err 异样编译不通过/** * 4.创立泛型为Integer的List类，把该对象的援用地址指向泛型为Number的List */List<Integer> integerList = new ArrayList<Integer>();List<Number> numberListThree = integerList;//err 异样编译不通过- 第一步：咱们创立一个泛型为
Number的List，编译器查看泛型类别是否统一，统一编译通过（确认参数化类型） - 第二步：泛型
Number曾经填充结束，调用add函数，此时add入参泛型T曾经填充为Number，add可入参Number或其子类 - 第三步：咱们又创立一个泛型为
Number的List，编译器查看泛型类别是否统一，不统一编译失败，提醒谬误（确认参数化类型） - 第四步：其实与第三步一样，只是做了一个间接的援用（确认参数化类型）
如果要解决下面的编译不通过问题，就须要应用通配符，代码如下
/** * 1.上边界通配符，Number与Number子类 */List<? extends Number> numberListFour = new ArrayList<Number>();numberListFour = new ArrayList<Integer>();numberListFour = new ArrayList<Double>();numberListFour = new ArrayList<Long>();/** * 2.下边界通配符,Integer与Integer父类 */List<? super Integer> integerList = new ArrayList<Integer>();integerList = new ArrayList<Number>();integerList = new ArrayList<Object>();/** * 3. 无界通配符,类型不确定，任意类型 */List<?> list = new ArrayList<Integer>();list = new ArrayList<Number>();list = new ArrayList<Object>();list = new ArrayList<String>();最初再来说上边界通配符只读不写，下边界通配符只写不读到底是什么意思，用最简略的话来说
<? extends T>上边界通配符不作为函数入参，只作为函数返回类型，比方List<? extends T>的应用add函数会编译不通过，get函数则没问题<? super T>下边界通配符不作为函数返回类型，只作为函数入参，比方List<? super T>的add函数失常调用，get函数也没问题，但只会返回Object，所以意义不大
大家只须要记住下面的规定即可，如果想晓得为什么这样设计，能够去理解下P E C S (producer-extends,consumer-super)准则
最佳实际
置信过完基础理论大家很多货色都回顾起来了，不要焦急，当初开始进入正题，前面内容会有大量的代码实际，所以大家要坐稳了，别晕车了，晕车的话多看几遍，或者评论区提出你的疑难~
有限通配符场景
应用泛型，类型参数不确定并且不关怀理论的类型参数，就能够应用<?>，像上面的代码
/** * 获取汇合长度 */public static <T> int size(Collection<T> list){ return list.size();}/** * 获取汇合长度-2 */public static int sizeTwo(Collection<?> list){ return list.size();}/** * 获取任意Set两个汇合交加数量 */public static <T,T2> int beMixedSum(Set<T> s1,Set<T2> s2){ int i = 0; for (T t : s1) { if (s2.contains(t)) { i++; } } return i;}/** * 获取任意两个Set汇合交加数量-2 */public static int beMixedSumTwo(Set<?> s1,Set<?> s2){ int i = 0; for (Object o : s1) { if (s2.contains(o)) { i++; } } return i;}size与sizeTwo这两个函数都能够失常应用，然而站在设计的角度，sizeTwo会更适合，函数的指标是返回任意汇合的长度，入参采纳<T>或<?>都能够接管，然而函数自身并不关怀你是什么类型参数，仅仅只有返回长度即可，所以采纳<?>。
beMixedSum与beMixedSumTwo这两个函数比拟，情理同下面一样，beMixedSumTwo会更适合，函数的指标是返回两个任意Set汇合的交加数量，beMixedSum函数尽管外部有应用到<T>，然而意义不大，因为contains入参是Object，函数自身并不关怀你是什么类型参数，所以采纳<?>。
忘了补充另一个场景，就是原生态类型，上述代码应用原生态类型函数应用也没问题，然而强烈不举荐，因为应用原生态就失落了泛型带来的安全性与描述性！！！
高低边界通配符场景
首先泛型是不变的，换句话说List<Object> != List<String>，有时候须要更多灵活性，就能够通过高低边界通配符来做晋升。
/** * 汇合工具类 */public class CollectionUtils<T>{ /** * 复制汇合-泛型 */ public List<T> listCopy(Collection<T> collection){ List<T> newCollection = new ArrayList<>(); for (T t : collection) { newCollection.add(t); } return newCollection; } }下面申明了一个CollectionUtils类，领有listCopy办法，传入任意一个汇合返回新的汇合，看似没有什么问题，也很灵便，那再看看上面这段代码。
public static void main(String[] agrs){ CollectionUtils<Number> collectionUtils = new CollectionUtils<>(); List<Number> list = new ArrayList<>(); //list.add.... List<Integer> listTwo = new ArrayList<>(); //listTwo.add.... List<Double> listThree = new ArrayList<>(); //listThree.add.... List<Number> list1 = collectionUtils.listCopy(list); list1 = collectionUtils.listCopy(listTwo);//err 编译异样 list1 = collectionUtils.listCopy(listThree);//err 编译异样}创立CollectionUtils类，泛型的类型参数为Number，listCopy函数入参的泛型填充为Number，此时listCopy只反对泛型为Number的List，如果要让它同时反对泛型为Number子类的List，就须要应用上边界通配符，咱们再追加一个办法
/** * 汇合工具 */public class CollectionUtils<T>{ /** * 复制汇合-泛型 */ public List<T> listCopy(Collection<T> collection){ List<T> newCollection = new ArrayList<>(); for (T t : collection) { newCollection.add(t); } return newCollection; } /** * 复制汇合-上边界通配符 */ public List<T> listCopyTwo(Collection<? extends T> collection){ List<T> newCollection = new ArrayList<>(); for (T t : collection) { newCollection.add(t); } return newCollection; }}public static void main(String[] agrs){ CollectionUtils<Number> collectionUtils = new CollectionUtils<>(); List<Number> list = new ArrayList<>(); //list.add.... List<Integer> listTwo = new ArrayList<>(); //listTwo.add.... List<Double> listThree = new ArrayList<>(); //listThree.add.... List<Number> list1 = collectionUtils.listCopyTwo(list); list1 = collectionUtils.listCopyTwo(listTwo); list1 = collectionUtils.listCopyTwo(listThree);}当初应用listCopyTwo就没有问题，listCopyTwo比照listCopy它的适用范围更宽泛也更灵便，listCopy能做的listCopyTwo能做，listCopyTwo能做的listCopy就不肯定能做了，除此之外，仔细的小伙伴必定发现了，应用上边界通配符的collection在函数内只应用到了读操作，遵循了只读不写准则。
看完了上边界通配符，再来看看下边界通配符，仍然是复制办法
/** * 儿子 */public class Son extends Father{}/** * 父亲 */public class Father extends Grandpa{}/** * 爷爷 */public class Grandpa {}/** * 汇合工具 */public class CollectionUtils<T>{ /** * 复制汇合-泛型 * target指标 src起源 */ public void copy(List<T> target,List<T> src){ if (src.size() > target.size()){ for (int i = 0; i < src.size(); i++) { target.set(i,src.get(i)); } } } }定义了3个类，别离是Son儿子、Father父亲、Grandpa爷爷，它们是继承关系，作为汇合元素，还申明了一个CollectionUtils类，领有copy办法，传入两个汇合，指标汇合与起源汇合，把起源汇合元素复制到指标汇合中，再看看上面这段代码
public static void main(String[] agrs){ CollectionUtils<Father> collectionUtils = new CollectionUtils<>(); List<Father> fatherTargets = new ArrayList<>(); List<Father> fatherSources = new ArrayList<>(); //fatherSources.add... collectionUtils.copy(fatherTargets,fatherSources); //子类复制到父类 List<Son> sonSources = new ArrayList<>(); //sonSources.add... collectionUtils.copy(fatherTargets,sonSources);//err 编译异样 }创立CollectionUtils类，泛型的类型参数为Father父亲，copy函数入参的泛型填充为Father，此时copy只反对泛型为Father的List，也就说，只反对泛型的类型参数为Father之间的复制，如果想反对把子类复制到父类要怎么做，先剖析下copy函数，copy函数的入参src在函数外部只波及到了get函数，即读操作（泛型只作为get函数返回类型），合乎只读不写准则，能够采纳上边界通配符，调整代码如下
/** * 汇合工具 */public class CollectionUtils<T>{ /** * 复制汇合-泛型 * target指标 src起源 */ public void copy(List<T> target,List<? extends T> src){ if (src.size() > target.size()){ for (int i = 0; i < src.size(); i++) { target.set(i,src.get(i)); } } }}public static void main(String[] agrs){ CollectionUtils<Father> collectionUtils = new CollectionUtils<>(); List<Father> fatherTargets = new ArrayList<>(); List<Father> fatherSources = new ArrayList<>(); //fatherSources.add... collectionUtils.copy(fatherTargets,fatherSources); //子类复制到父类 List<Son> sonSources = new ArrayList<>(); //sonSources.add... collectionUtils.copy(fatherTargets,sonSources); //把子类复制到父类的父类 List<Grandpa> grandpaTargets = new ArrayList<>(); collectionUtils.copy(grandpaTargets,sonSources);//err 编译异样}src入参调整为上边界通配符后，copy函数传入List<Son> sonSources就没问题了，此时的copy函数比相较之前的更加灵便了，反对同类与父子类复制，接着又发现了一个问题，目前能复制到上一级父类，如果是多级父类，还无奈反对，持续剖析copy函数，copy函数的入参target在函数外部只波及到了add函数，即写操作（只作为add函数入参），合乎只写不读准则，能够采纳下边界通配符，调整代码如下
/** * 汇合工具 */public class CollectionUtils<T>{ /** * 复制汇合-泛型 * target指标 src起源 */ public void copy(List<? super T> target,List<? extends T> src){ if (src.size() > target.size()){ for (int i = 0; i < src.size(); i++) { target.set(i,src.get(i)); } } }}public static void main(String[] agrs){ CollectionUtils<Father> collectionUtils = new CollectionUtils<>(); List<Father> fatherTargets = new ArrayList<>(); List<Father> fatherSources = new ArrayList<>(); //fatherSources.add... collectionUtils.copy(fatherTargets,fatherSources); //子类复制到父类 List<Son> sonSources = new ArrayList<>(); //sonSources.add... collectionUtils.copy(fatherTargets,sonSources); //把子类复制到父类的父类 List<Grandpa> grandpaTargets = new ArrayList<>(); collectionUtils.copy(grandpaTargets,sonSources);}copy函数终于是欠缺了，能够说当初是真正反对父子类复制，不难发现copy函数的设计还是遵循通配符准则的，target作为指标汇合，只做写入，合乎只写不读准则，采纳了下边界通配符，src作为起源汇合写入到target指标汇合，只做读取，合乎只读不写准则，采纳了上边界通配符，最初设计进去的copy函数，它的灵活性与适用范围是远超<T>形式设计的。
最初总结一下，什么时候用通配符，如果参数泛型类即要读也要写，那么就不举荐应用，应用失常的泛型即可，如果参数泛型类只读或写，就能够依据准则采纳对应的高低边界，是不是非常简略，最初再说一次读写的含意，这块的确很容易晕
- 读：所谓读是指参数泛型类，泛型只作为该参数类的函数返回类型，那这个函数就是读，
List作为参数泛型类，它的get函数就是读 - 写：所谓写是指参数泛型类，泛型只作为该参数类的函数入参，那这个函数就是写，
List作为参数泛型类，它的add函数就是读
最初能够举荐下大家能够思考下Stream的forEach函数与map函数的设计，在Java1.8 Stream中是大量用到了通配符设计
-----------------------------------------------------------------/** * 下边界通配符 */void forEach(Consumer<? super T> action);public interface Consumer<T> { //写办法 void accept(T t);}-----------------------------------------------------------------/** * 高低边界通配符 */<R> Stream<R> map(Function<? super T, ? extends R> mapper)public interface Function<T, R> { //读写办法，T只作为入参合乎写，R只作为返回值，合乎读 R apply(T t);}-----------------------------------------------------------------//代码案例public static void main(String[] agrs) { List<Father> fatherList = new ArrayList<>(); Consumer<? super Father> action = new Consumer<Father>() { @Override public void accept(Father father) { //执行father逻辑 } }; //下边界通配符向上转型 Consumer<? super Father> actionTwo = new Consumer<Grandpa>() { @Override public void accept(Grandpa grandpa) { //执行grandpa逻辑 } }; Function<? super Father, ? extends Grandpa> mapper = new Function<Father, Grandpa>() { @Override public Grandpa apply(Father father) { //执行father逻辑后返回Grandpa return new Grandpa(); } }; //下边界通配符向上转型，下边界通配符向下转型 Function<? super Father, ? extends Grandpa> mapperTwo = new Function<Grandpa, Son>() { @Override public Son apply(Grandpa grandpa) { //执行grandpa逻辑后，返回Son return new Son(); } }; fatherList.stream().forEach(action); fatherList.stream().forEach(actionTwo); fatherList.stream().map(mapper); fatherList.stream().map(mapperTwo); }-----------------------------------------------------------------有限度泛型场景
有限度泛型很简略了，利用场景就是你须要对泛型的参数类型做限度，就能够应用它，比方上面这段代码
public class GenericClass<T extends Grandpa> { public void test(T t){ //.... }}public static void main(String[] agrs){ GenericClass<Grandpa> grandpaGeneric = new GenericClass<>(); grandpaGeneric.test(new Grandpa()); grandpaGeneric.test(new Father()); grandpaGeneric.test(new Son()); GenericClass<Father> fatherGeneric = new GenericClass<>(); fatherGeneric.test(new Father()); fatherGeneric.test(new Son()); GenericClass<Son> sonGeneric = new GenericClass<>(); sonGeneric.test(new Son()); GenericClass<Object> ObjectGeneric = new GenericClass<>();//err 编译异样 }GenericClass泛型参数化类型被限度为Grandpa或其子类，就这么简略，千万不要把有限度泛型与上边界通配符搞混了，这两个不是同一个货色（<T extends Grandpa> != <? extends Grandpa>），<T extends Grandpa>不须要遵循上边界通配符的准则，它就是简略的泛型参数化类型限度，而且没有super的写法。
递归泛型场景
在有限度泛型的根底上，又能够衍生出递归泛型，就是本身须要应用到本身，比方汇合进行自定义元素大小比拟的时候，通常会配合Comparable接口来实现，看看上面这段代码
public class Person implements Comparable<Person> { private int age; public Person(int age) { this.age = age; } public int getAge() { return age; } @Override public int compareTo(Person o) { // 0代表相等 1代表大于 <0代表小于 return this.age - o.age; }}/** * 汇合工具 */public class CollectionUtils{ /** * 获取汇合最大值 */ public static <E extends Comparable<E>> E max(List<E> list){ E result = null; for (E e : list) { if (result == null || e.compareTo(result) > 0){ result = e; } } return result; }}public static void main(String[] agrs){ List<Person> personList = new ArrayList<>(); personList.add(new Person(12)); personList.add(new Person(19)); personList.add(new Person(20)); personList.add(new Person(5)); personList.add(new Person(18)); //返回年龄最大的Person元素 Person max = CollectionUtils.max(personList);}重点关注max泛型函数，max泛型函数的指标是返回汇合最大的元素，外部比拟元素大小，取最大值返回，也就说须要和同类型元素做比拟，<E extends Comparable<E>>含意是，泛型E必须是Comparable或其子类/实现类，因为比拟元素是同类型，所以Comparable泛型也是E,最终接管的List泛型参数化类型必须实现了Comparable接口，并且Comparable接口填充的泛型也是该参数化类型，就像上述代码一样。
对于我
这里是阿星，一个酷爱技术的Java程序猿，在公众号 「程序猿阿星」 里将会定期分享操作系统、计算机网络、Java、分布式、数据库等精品原创文章，2021，与您在 Be Better 的路上独特成长！。
非常感谢各位人才能 看到这里，原创不易，文章有帮忙能够「点个赞」或「分享与评论」，都是反对（莫要白嫖）！
愿你我都能奔赴在各自想去的路上，咱们下篇文章见！