基础知识

编译期和运行期

编译期：是指把源码交给编译器编译成计算机可执行文件的过程。
运行期：是指把编译后的文件交给计算机执行，直到程序结束。

在Java中就是把 .java文件编译成 .class文件，再把编译后的文件交给 JVM加载执行，如下图所示
image.png

泛型

泛型，即“参数化类型”,是JDK5.0出现的新特性，解决数据类型的安全性问题。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型类

image.png
类上定义泛型，作用于类的成员变量与函数，代码实例如下：

  1. public class GenericClass<T>{
  2.     //成员变量
  3.     private T t;
  5.     public  void function(T t){
  7.     }
  9.     public T functionTwo(T t){
  10.        //注意，这个不是泛型方法！！！
  11.        return t;
  12.     }
  13. }

泛型接口

image.png
接口上定义泛型，作用于函数，代码实例如下：

  1. public interface GenericInterface<T> {
  3.     public T get();
  5.     public void set(T t);
  7.     public T delete(T t);
  9.     default T defaultFunction(T t){
  10.         return t;
  11.     }
  12. }

泛型方法

image.png

image.png
函数返回类型旁加上泛型，作用于函数，代码实例如下：
注意：
1）public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。
2）只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
3）表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

Java泛型中的标记符含义： E - Element (在集合中使用，因为集合中存放的是元素) T - Type（Java 类） K - Key（键） V - Value（值） N - Number（数值类型） ？ - 表示不确定的java类型 S、U、V - 2nd、3rd、4th types

  1. public class GenericFunction {
  3.     public <T> void function(T t) {
  4.     }
  6.     public <T> T functionTwo(T t) {
  7.         return t;
  8.     }
  10.     public <T> String functionThree(T t) {
  11.         return "";
  12.     }
  13. }

通配符

通配符是为了让Java泛型支持范围限定，这样使得泛型的灵活性提升，同时也让通用性设计有了更多的空间。

  • <?>：无界通配符，即类型不确定，任意类型
  • <? extends T>：上边界通配符，即?是继承自T的任意子类型，遵守只读不写
  • <? super T>：下边界通配符，即?是T的任意父类型，遵守只写不读

相信大部分人，都是倒在通配符这块，这里多唠叨点，「通配符限定的范围是体现在确认“参数化类型”的时候，而不是“参数化类型”填充后」，可能这句话不太好理解，来看看下面的代码

  1. /**
  2.  * 1.创建泛型为Number的List类，Integer、Double、Long等都是Number的子类
  3.  *   new ArrayList<>() 等价于 new ArrayList<Number>()
  4.  */
  5. List<Number> numberList = new ArrayList<Number>();
  7. /**
  8.  * 2.添加不同子类
  9.  */
  10. numberList.add(1);//添加Integer类型
  11. numberList.add(0.5);//添加Double类型
  12. numberList.add(10000L);//添加Long类型
  14. /**
  15.  * 3.创建泛型为Number的List类，Integer、Double、Long等都是Number的子类
  16.  *   引用是泛型类别是Number，但具体实现指定的泛型是Integer
  17.  */
  18. List<Number> numberListTwo = new ArrayList<Integer>();//err 异常编译不通过
  20. /**
  21.  * 4.创建泛型为Integer的List类，把该对象的引用地址指向泛型为Number的List
  22.  */
  23. List<Integer> integerList = new ArrayList<Integer>();
  24. List<Number> numberListThree = integerList;//err 异常编译不通过
  • 第一步：我们创建一个泛型为Number的List，编译器检查泛型类别是否一致，一致编译通过（确认参数化类型）
  • 第二步：泛型Number已经填充完毕，调用add函数，此时add入参泛型T已经填充为Number，add可入参Number或其子类
  • 第三步：我们又创建一个泛型为Number的List，编译器检查泛型类别是否一致，不一致编译失败，提示错误（确认参数化类型）
  • 第四步：其实与第三步一样，只是做了一个间接的引用（确认参数化类型）

如果要解决上面的编译不通过问题，就需要使用通配符，代码如下：

  1. /**
  2.  * 1.上边界通配符，Number与Number子类
  3.  */
  4. List<? extends Number> numberListFour = new ArrayList<Number>();
  5. numberListFour = new ArrayList<Integer>();
  6. numberListFour = new ArrayList<Double>();
  7. numberListFour = new ArrayList<Long>();
  9. /**
  10.  * 2.下边界通配符,Integer与Integer父类
  11.  */
  12. List<? super Integer> integerList = new ArrayList<Integer>();
  13. integerList = new ArrayList<Number>();
  14. integerList = new ArrayList<Object>();
  16. /**
  17.  * 3. 无界通配符,类型不确定，任意类型
  18.  */
  19. List<?> list = new ArrayList<Integer>();
  20. list = new ArrayList<Number>();
  21. list = new ArrayList<Object>();
  22. list = new ArrayList<String>();

最后再来说上边界通配符只读不写，下边界通配符只写不读到底是什么意思，用最简单的话来说：

  • <? extends T>上边界通配符不作为函数入参，只作为函数返回类型，比如List<? extends T>的使用add函数会编译不通过，get函数则没问题
  • <? super T>下边界通配符不作为函数返回类型，只作为函数入参，比如List<? super T>的add函数正常调用，get函数也没问题，但只会返回Object，所以意义不大

大家只需要记住上面的规则即可，如果想知道为什么这样设计，可以去了解下PECS (producer-extends,consumer-super)原则

最佳实践

无限通配符场景

使用泛型，类型参数不确定并且不关心实际的类型参数，就可以使用<?>，像下面的代码

  1. /**
  2.  * 获取集合长度
  3.  */
  4. public static <T> int size(Collection<T> list){
  5.     return list.size();
  6. }
  8. /**
  9.  * 获取集合长度-2
  10.  */
  11. public static int sizeTwo(Collection<?>  list){
  12.     return list.size();
  13. }
  16. /**
  17.  * 获取任意Set两个集合交集数量
  18.  */
  19. public static <T,T2> int beMixedSum(Set<T> s1,Set<T2> s2){
  20.     int i = 0;
  21.     for (T t : s1) {
  22.         if (s2.contains(t)) {
  23.             i++;
  24.         }
  25.     }
  26.     return i;
  27. }
  29. /**
  30.  * 获取任意两个Set集合交集数量-2
  31.  */
  32. public static  int beMixedSumTwo(Set<?> s1,Set<?> s2){
  33.     int i = 0;
  34.     for (Object o : s1) {
  35.         if (s2.contains(o)) {
  36.             i++;
  37.         }
  38.     }
  39.     return i;
  40. }

size与sizeTwo这两个函数都可以正常使用，但是站在设计的角度，sizeTwo会更合适，函数的目标是返回任意集合的长度，入参采用或<?>都可以接收，但是函数本身并不关心你是什么类型参数，仅仅只要返回长度即可，所以采用<?>。
beMixedSum与beMixedSumTwo这两个函数比较，道理同上面一样，beMixedSumTwo会更合适，函数的目标是返回两个任意Set集合的交集数量，beMixedSum函数虽然内部有使用到，但是意义不大，因为contains入参是Object，函数本身并不关心你是什么类型参数，所以采用<?>。
忘了补充另一个场景，就是原生态类型，上述代码使用原生态类型函数使用也没问题，但是强烈不推荐，因为使用原生态就丢失了泛型带来的安全性与描述性！！！

上下边界通配符场景

首先泛型是不变的，换句话说List != List，有时候需要更多灵活性，就可以通过上下边界通配符来做提升。

  1. /**
  2.  * 集合工具类
  3.  */
  4. public class CollectionUtils<T>{
  6.     /**
  7.      * 复制集合-泛型
  8.      */
  9.     public List<T>  listCopy(Collection<T> collection){
  10.         List<T> newCollection = new ArrayList<>();
  11.         for (T t : collection) {
  12.             newCollection.add(t);
  13.         }
  14.         return newCollection;
  15.     }
  17. }

上面声明了一个CollectionUtils类，拥有listCopy方法，传入任意一个集合返回新的集合，看似没有什么问题，也很灵活，那再看看下面这段代码。

  1. public static void main(String[] agrs){
  2.     CollectionUtils<Number> collectionUtils = new CollectionUtils<>();
  3.     List<Number>  list = new ArrayList<>();
  4.     //list.add....
  5.     List<Integer>  listTwo = new ArrayList<>();
  6.     //listTwo.add....
  7.     List<Double>  listThree = new ArrayList<>();
  8.     //listThree.add....
  10.     List<Number> list1 = collectionUtils.listCopy(list);
  11.     list1 = collectionUtils.listCopy(listTwo);//err 编译异常
  12.     list1 = collectionUtils.listCopy(listThree);//err 编译异常
  13. }

创建CollectionUtils类，泛型的类型参数为Number，listCopy函数入参的泛型填充为Number，此时listCopy只支持泛型为Number的List，如果要让它同时支持泛型为Number子类的List，就需要使用上边界通配符，我们再追加一个方法

  1. /**
  2.  * 集合工具
  3.  */
  4. public class CollectionUtils<T>{
  6.     /**
  7.      * 复制集合-泛型
  8.      */
  9.     public List<T>  listCopy(Collection<T> collection){
  10.         List<T> newCollection = new ArrayList<>();
  11.         for (T t : collection) {
  12.             newCollection.add(t);
  13.         }
  14.         return newCollection;
  15.     }
  17.     /**
  18.      * 复制集合-上边界通配符
  19.      */
  20.     public  List<T>  listCopyTwo(Collection<? extends T> collection){
  21.         List<T> newCollection = new ArrayList<>();
  22.         for (T t : collection) {
  23.             newCollection.add(t);
  24.         }
  25.         return newCollection;
  26.     }
  27. }
  29. public static void main(String[] agrs){
  30.     CollectionUtils<Number> collectionUtils = new CollectionUtils<>();
  31.     List<Number>  list = new ArrayList<>();
  32.     //list.add....
  33.     List<Integer>  listTwo = new ArrayList<>();
  34.     //listTwo.add....
  35.     List<Double>  listThree = new ArrayList<>();
  36.     //listThree.add....
  38.     List<Number> list1 = collectionUtils.listCopyTwo(list);
  39.     list1 = collectionUtils.listCopyTwo(listTwo);
  40.     list1 = collectionUtils.listCopyTwo(listThree);
  41. }

现在使用listCopyTwo就没有问题，listCopyTwo对比listCopy它的适用范围更广泛也更灵活，listCopy能做的listCopyTwo能做，listCopyTwo能做的listCopy就不一定能做了，除此之外，细心的小伙伴肯定发现了，使用上边界通配符的collection在函数内只使用到了读操作，遵循了只读不写原则。

看完了上边界通配符，再来看看下边界通配符，依然是复制方法

  1. /**
  2.  * 儿子
  3.  */
  4. public class Son extends Father{}
  6. /**
  7.  * 父亲
  8.  */
  9. public class Father  extends  Grandpa{}
  11. /**
  12.  * 爷爷
  13.  */
  14. public class Grandpa {}
  16. /**
  17.  * 集合工具
  18.  */
  19. public class CollectionUtils<T>{
  21.     /**
  22.      * 复制集合-泛型
  23.      * target目标   src来源
  24.      */
  25.    public void copy(List<T> target,List<T> src){
  26.         if (src.size() > target.size()){
  27.             for (int i = 0; i < src.size(); i++) {
  28.                 target.set(i,src.get(i));
  29.             }
  30.         }
  31.     }
  33. }

定义了3个类，分别是Son儿子、Father父亲、Grandpa爷爷，它们是继承关系，作为集合元素，还声明了一个CollectionUtils类，拥有copy方法，传入两个集合，目标集合与来源集合，把来源集合元素复制到目标集合中，再看看下面这段代码

  1. public static void main(String[] agrs){
  2.     CollectionUtils<Father> collectionUtils = new CollectionUtils<>();
  4.     List<Father>  fatherTargets = new ArrayList<>();
  5.     List<Father>  fatherSources = new ArrayList<>();
  6.     //fatherSources.add...
  7.     collectionUtils.copy(fatherTargets,fatherSources);
  9.     //子类复制到父类
  10.     List<Son> sonSources = new ArrayList<>();
  11.     //sonSources.add...
  12.     collectionUtils.copy(fatherTargets,sonSources);//err 编译异常
  14. }

创建CollectionUtils类，泛型的类型参数为Father父亲，copy函数入参的泛型填充为Father，此时copy只支持泛型为Father的List，也就说，只支持泛型的类型参数为Father之间的复制，如果想支持把子类复制到父类要怎么做，先分析下copy函数，copy函数的入参src在函数内部只涉及到了get函数，即读操作（泛型只作为get函数返回类型），符合只读不写原则，可以采用上边界通配符，调整代码如下

  1. /**
  2.  * 集合工具
  3.  */
  4. public class CollectionUtils<T>{
  6.     /**
  7.      * 复制集合-泛型
  8.      * target目标   src来源
  9.      */
  10.     public void copy(List<T> target,List<? extends T> src){
  11.         if (src.size() > target.size()){
  12.             for (int i = 0; i < src.size(); i++) {
  13.                 target.set(i,src.get(i));
  14.             }
  15.         }
  16.     }
  17. }
  19. public static void main(String[] agrs){
  20.     CollectionUtils<Father> collectionUtils = new CollectionUtils<>();
  22.     List<Father>  fatherTargets = new ArrayList<>();
  23.     List<Father>  fatherSources = new ArrayList<>();
  24.     //fatherSources.add...
  25.     collectionUtils.copy(fatherTargets,fatherSources);
  27.     //子类复制到父类
  28.     List<Son> sonSources = new ArrayList<>();
  29.     //sonSources.add...
  30.     collectionUtils.copy(fatherTargets,sonSources);
  32.     //把子类复制到父类的父类
  33.     List<Grandpa> grandpaTargets = new ArrayList<>();
  34.     collectionUtils.copy(grandpaTargets,sonSources);//err 编译异常
  35. }

copy函数终于是完善了，可以说现在是真正支持父子类复制，不难发现copy函数的设计还是遵循通配符原则的，target作为目标集合，只做写入，符合只写不读原则，采用了下边界通配符，src作为来源集合，只做读取，符合只读不写原则，采用了上边界通配符，最后设计出来的copy函数，它的灵活性与适用范围是远超方式设计的。
最后总结一下，什么时候用通配符，如果参数泛型类即要读也要写，那么就不推荐使用，使用正常的泛型即可，如果参数泛型类只读或写，就可以根据原则采用对应的上下边界，是不是十分简单，最后再说一次读写的含义，这块确实很容易晕

  • 读：所谓读是指参数泛型类，泛型只作为该参数类的函数返回类型，那这个函数就是读，List作为参数泛型类，它的get函数就是读
  • 写：所谓写是指参数泛型类，泛型只作为该参数类的函数入参，那这个函数就是写，List作为参数泛型类，它的add函数就是读

留给小题，大家可以思考下Stream的forEach函数与map函数的设计，在Java1.8 Stream中是大量用到了通配符设计

  1. -----------------------------------------------------------------
  2. /**
  3.  * 下边界通配符
  4.  */
  5. void forEach(Consumer<? super T> action);
  7. public interface Consumer<T> {
  9.     //写方法
  10.     void accept(T t);
  11. }
  13. -----------------------------------------------------------------
  14. /**
  15.  * 上下边界通配符
  16.  */
  17. <R> Stream<R> map(Function<? super T, ? extends R> mapper)
  19. public interface Function<T, R> {
  21.      //读写方法，T只作为入参符合写，R只作为返回值，符合读
  22.     R apply(T t);
  23. }
  24. -----------------------------------------------------------------
  26. //代码案例
  27. public static void main(String[] agrs) {
  29.         List<Father> fatherList = new ArrayList<>();
  31.         Consumer<? super Father> action = new Consumer<Father>() {
  32.             @Override
  33.             public void accept(Father father) {
  34.                 //执行father逻辑
  35.             }
  36.         };
  38.          //下边界通配符向上转型
  39.         Consumer<? super Father> actionTwo = new Consumer<Grandpa>() {
  40.             @Override
  41.             public void accept(Grandpa grandpa) {
  42.                 //执行grandpa逻辑
  43.             }
  44.         };
  46.          Function<? super Father, ? extends Grandpa> mapper = new Function<Father, Grandpa>() {
  47.             @Override
  48.             public Grandpa apply(Father father) {
  49.                 //执行father逻辑后返回Grandpa
  50.                 return new Grandpa();
  51.             }
  52.         };
  54.         //下边界通配符向上转型，上边界通配符向下转型
  55.          Function<? super Father, ? extends Grandpa> mapperTwo = new Function<Grandpa, Son>() {
  56.             @Override
  57.             public Son apply(Grandpa grandpa) {
  58.                 //执行grandpa逻辑后，返回Son
  59.                 return new Son();
  60.             }
  61.         };
  63.         fatherList.stream().forEach(action);
  64.         fatherList.stream().forEach(actionTwo);
  66.         fatherList.stream().map(mapper);
  67.         fatherList.stream().map(mapperTwo);
  70.     }
  71. -----------------------------------------------------------------

有限制泛型场景

有限制泛型很简单了，应用场景就是你需要对泛型的参数类型做限制，就可以使用它，比如下面这段代码

  1. public class GenericClass<T extends Grandpa> {
  4.     public void test(T t){
  5.         //....
  6.     }
  8. }
  10. public static void main(String[] agrs){
  11.     GenericClass<Grandpa> grandpaGeneric = new GenericClass<>();
  12.     grandpaGeneric.test(new Grandpa());
  13.     grandpaGeneric.test(new Father());
  14.     grandpaGeneric.test(new Son());
  16.     GenericClass<Father> fatherGeneric = new GenericClass<>();
  17.     fatherGeneric.test(new Father());
  18.     fatherGeneric.test(new Son());
  20.     GenericClass<Son> sonGeneric = new GenericClass<>();
  21.     sonGeneric.test(new Son());
  23.     GenericClass<Object> ObjectGeneric = new GenericClass<>();//err 编译异常
  25. }

GenericClass泛型参数化类型被限制为Grandpa或其子类，就这么简单，千万不要把有限制泛型与上边界通配符搞混了，这两个不是同一个东西（ != <? extends Grandpa>），不需要遵循上边界通配符的原则，它就是简单的泛型参数化类型限制，而且没有super的写法。

递归泛型场景

在有限制泛型的基础上，又可以衍生出递归泛型，就是自身需要使用到自身，比如集合进行自定义元素大小比较的时候，通常会配合Comparable接口来完成，看看下面这段代码

  1. public class Person implements Comparable<Person> {
  3.     private int age;
  5.     public Person(int age) {
  6.         this.age = age;
  7.     }
  9.     public int getAge() {
  10.         return age;
  11.     }
  13.     @Override
  14.     public int compareTo(Person o) {
  15.         // 0代表相等 1代表大于  <0代表小于    
  16.         return this.age - o.age;
  17.     }
  18. }
  21. /**
  22.  * 集合工具
  23.  */
  24. public class CollectionUtils{
  26.     /**
  27.      * 获取集合最大值
  28.      */
  29.     public static  <E extends Comparable<E>> E max(List<E> list){
  30.         E result = null;
  31.         for (E e : list) {
  32.              if (result == null || e.compareTo(result) > 0){
  33.                  result = e;
  34.              }
  35.         }
  36.         return result;
  37.     }
  38. }
  41. public static void main(String[] agrs){
  43.     List<Person> personList = new ArrayList<>();
  44.     personList.add(new Person(12));
  45.     personList.add(new Person(19));
  46.     personList.add(new Person(20));
  47.     personList.add(new Person(5));
  48.     personList.add(new Person(18));
  49.     //返回年龄最大的Person元素 
  50.     Person max = CollectionUtils.max(personList);
  52. }

重点关注max泛型函数，max泛型函数的目标是返回集合最大的元素，内部比较元素大小，取最大值返回，也就说需要和同类型元素做比较，>含义是，泛型E必须是Comparable或其子类/实现类，因为比较元素是同类型，所以Comparable泛型也是E,最终接收的List泛型参数化类型必须实现了Comparable接口，并且Comparable接口填充的泛型也是该参数化类型，就像上述代码一样。