万字文详解Java泛型

1. 文章优先发布在Github，其它平台会晚一段时间，文章纠错与更新内容只在Github：https://github.com/youthlql/JavaYouth
2. 转载须知：转载请注明GitHub出处，让我们一起维护一个良好的技术创作环境。
3. 如果你要提交 issue 或者 pr 的话建议到 Github 提交。笔者会陆续更新，如果对你有所帮助，不妨Github点个Star~。你的Star是我创作的动力。
   

        

简介

泛型的优点

1、泛型的本质是为了参数化类型，也就是在在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型，很明显这种方法提高了代码的复用性。

2、泛型的引入提高了安全性，泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。。

3、在没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是本身就是一个安全隐患。

那么泛型的好处就是在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的。

public class GlmapperGeneric<T> {
		private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
  
    public static void main(String[] args) {
        // do nothing
    }

  /**
    * 不指定类型
    */
  public void noSpecifyType(){
    GlmapperGeneric glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 需要强制类型转换
    String test = (String) glmapperGeneric.get();
    System.out.println(test);
  }

  /**
    * 指定类型
    */
  public void specifyType(){
    GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 不需要强制类型转换
    String test = glmapperGeneric.get();
    System.out.println(test);
  }
}

为什么提高了安全性？

再举例子说明一下

不安全举例

package keyAndDifficultPoints.Generic;


import java.util.ArrayList;
import java.util.List;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 16:09
 * 

 * 功能描述:
 */
public class Test_Safe {

    public static void main(String[] args) {
        test();
    }

    public static void test() {
        List arrayList = new ArrayList();
        arrayList.add("aaaa");
        arrayList.add(100);

        for (int i = 0; i < arrayList.size(); i++) {
            String s = (String) arrayList.get(i);
            System.out.println(s);

        }
    }
}    

结果：

aaaa
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at keyAndDifficultPoints.Generic.Test_Safe.test(Test_Safe.java:25)
	at keyAndDifficultPoints.Generic.Test_Safe.main(Test_Safe.java:16)

很明显的一个类型转换错误。ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

泛型提高安全性

将上面的代码稍微改一下

 public static void test01(){
        List arrayList = new ArrayList<>();
        arrayList.add("aaaa");
        //下面代码编译时就直接报错了
        arrayList.add(100);

        for (int i = 0; i < arrayList.size(); i++) {
            String s = (String) arrayList.get(i);
            System.out.println(s);

        }
    }

通过泛型来提前检测类型，编译时就通不过。

泛型为什么很重要

我们看一下比较常用的JUC包

public  CompletableFuture thenComposeAsync(
        Function> fn) {
        return uniComposeStage(asyncPool, fn);
    }

    public  CompletableFuture thenComposeAsync(
        Function> fn,
        Executor executor) {
        return uniComposeStage(screenExecutor(executor), fn);
    }

    public CompletableFuture whenComplete(
        BiConsumer action) {
        return uniWhenCompleteStage(null, action);
    }

    public CompletableFuture whenCompleteAsync(
        BiConsumer action) {
        return uniWhenCompleteStage(asyncPool, action);
    }

这些都大量的用到了泛型，如果不把泛型学好，想真正深入源码了解一些东西，可能就完全看不懂了。

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

最普通的泛型类：

package keyAndDifficultPoints.Generic;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 16:38
 * 

 * 功能描述:
 */
public class Test_GenericClass {
    public static void main(String[] args) {
        test();
    }

    public static void test(){
        /**
         * 1、泛型的类型参数只能是类类型（包括自定义类），不能是简单数据类型（比如int,long这些）
         * 2、传入的实参类型需与泛型的类型参数类型相同，即为这里的Integer。
         * 3、new 后面的泛型参数可以省略
         */
        Generic genericInteger1 = new Generic(123);
        Generic genericInteger = new Generic<>(123);

        Generic genericString = new Generic("my");

        System.out.println(genericInteger.getVar());
        System.out.println(genericString.getVar());
    }


}

/**
 * 1、此处T虽然可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 * 但是为了代码的可读性一般来说：
 * K,V用来表示键值对
 * E是Element的缩写，常用来遍历时表示
 * T就是Type的缩写，常用在普通泛型类上
 * 2、还有一些不常见的U,R啥的
 */
class Generic {
    //key这个成员变量的类型为T,T的类型由外部指定
    private T var;

    public Generic(T var) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.var = var;
    }

    public T getVar() { //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return var;
    }
}

class MyMap {       // 此处指定了两个泛型类型
    private K key;     // 此变量的类型由外部决定
    private V value;   // 此变量的类型由外部决定

    public K getKey() {
        return this.key;
    }

    public V getValue() {
        return this.value;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }
};

结果：

123
my

Process finished with exit code 0

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

还是以上面的泛型类为例进行测试

 public static void test01() {
        Generic generic = new Generic("我是字符串");
        Generic generic1 = new Generic(123);
        Generic generic2 = new Generic(123.123);
        Generic generic3 = new Generic(false);

        System.out.println(generic.getVar());
        System.out.println(generic1.getVar());
        System.out.println(generic2.getVar());
        System.out.println(generic3.getVar());
    }

结果：

我是字符串
123
123.123
false

Process finished with exit code 0

没有报错，正确输出了。

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

interface Info{        // 在接口上定义泛型  
    public T getVar() ; // 定义方法，方法的返回值就是泛型类型  
} 

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

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class InfoImpl implements Info
 * 如果不声明泛型，如：class InfoImpl implements Info，编译器会报错："Unknown class"
 */
class InfoImpl<T> implements Info<T> {   // 定义泛型接口的子类
    private T var;

    public InfoImpl(T var) {
        this.setVar(var);
    }

    public void setVar(T var) {
        this.var = var;
    }

    public T getVar() {
        return this.var;
    }
}

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

/**
 * 传入泛型实参时：
 * 定义一个是先烈实现这个接口,虽然我们只创建了一个泛型接口Info
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：InfoImpl01，public String getVar();中的的T都要替换成传入的String类型。
 */
class InfoImpl01 implements Info {   // 定义泛型接口的子类
    private String var;

    public InfoImpl01(String var) {
        this.setVar(var);
    }

    public void setVar(String var) {
        this.var = var;
    }

    public String getVar() {
        return this.var;
    }
}

泛型方法

在java中，泛型类和接口的定义非常简单，但是泛型方法就比较复杂了。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

最简单的一个泛型方法

public class Test_GenericMethod {

    public static void main(String[] args) {
        Test_GenericMethod test_genericMethod = new Test_GenericMethod();
        Integer integer = test_genericMethod.genericMethod(12);
        System.out.println(integer);
    }

    /**
     * 说明：
     * 1、public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。
     * 2、只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     * 3、表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     * 4、 后面的这个T，代表这个方法的返回值类型
     * 4、与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
     */
    public  T genericMethod(T a) {

        return a;
    }
}

基本用法（非泛型类中的泛型方法）

下面来细说一下泛型方法

首先说一个误区

class Generic01 {
    private T key;

    public Generic01(T key) {
        this.key = key;
    }


    /**
     * 1、这个虽然在方法中使用了泛型，但这并不是一个泛型方法。这只是类中一个普通的
     * 成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。所以在这个方法中才
     * 可以继续使用 T 这个泛型。
     */
    public T getKey() {
        return key;
    }

    /**
     * 1、这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
     * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
     */
//    public E setKey(E key) {
//        this.key = key;
//    }

}

基本用法（非）

package keyAndDifficultPoints.Generic;


/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 17:46
 * 

 * 功能描述:
 */
public class Test_GenericMethod {

    public static void main(String[] args) {
        Test_GenericMethod test_genericMethod = new Test_GenericMethod();
        Generic01 generic01 = new Generic01<>(123);

        Generic01 generic02 = new Generic01<>("AAAAA");

        test_genericMethod.genericMethod_test01(generic01);
        test_genericMethod.genericMethod_test02(generic02, "我是T");

        test_genericMethod.Method01(generic01);
    }

    /**
     * 说明：
     * 1、public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。
     * 2、只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     * 3、表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     * 4、 后面的这个T，代表这个方法的返回值类型
     * 4、与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
     */
    public  T genericMethod(T a) {

        return a;
    }


    /**
     * 1、这才是一个真正的泛型方法。
     * 2、首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T。
     * 3、这个T可以出现在这个泛型方法的任意位置.泛型的数量也可以为任意多个
     */
    public  T genericMethod_test01(Generic01 generic01) {
        System.out.println("我是genericMethod_test01：" + generic01.getKey());
        T test = generic01.getKey();
        return test;
    }

    public  T genericMethod_test02(Generic01 generic01, V value) {
        System.out.println("我是genericMethod_test02：" + generic01.getKey() + "==> value：" + value);

        T test = generic01.getKey();
        return test;
    }


    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic这个泛型类做形参而已。
    public void Method01(Generic01 generic01) {
        System.out.println(generic01.getKey());
    }


    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void Method02(Generic01 generic01) {
        System.out.println(generic01.getKey());
    }

    /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
     */
//    public  T showKeyName(Generic01 generic01, T t) {
//        return t;
//    }

}

结果：

我是genericMethod_test01：123
我是genericMethod_test02：AAAAA==> value：我是T
123

Process finished with exit code 0

泛型类中的泛型方法

当然这并不是泛型方法的全部，泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下。

package keyAndDifficultPoints.Generic;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 20:14
 * 

 * 功能描述:
 */
public class Test_GenericMethod01 {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest generateTest = new GenerateTest();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

abstract class GenericFruit {

}

class Fruit {
    @Override
    public String toString() {
        return "fruit";
    }
}

class Apple extends Fruit {
    @Override
    public String toString() {
        return "apple";
    }
}

class Person {
    @Override
    public String toString() {
        return "Person";
    }
}

class GenerateTest {
    
    public void show_1(T t) {
        System.out.println(t.toString());
    }


    /**
     * 1、在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
     * 2、由于泛型方法在声明的时候会声明泛型，因此即使在泛型类中并未声明泛型，编译器也能够正确识别
     泛型方法中识别的泛型。
     */
    public  void show_3(E t) {
        System.out.println(t.toString());
    }


    /**
     * 1、在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T
     * 不是同一种类型。也就是说main函数中使用的时候也可以是不一样的泛型类型
     */
    public  void show_2(T t) {
        System.out.println(t.toString());
    }
}

结果：

apple
apple
Person
apple
Person

Process finished with exit code 0

泛型方法与可变参数

再看一个泛型方法和可变参数的例子：

public class Test_GenericMethod02 {
    public static void main(String[] args) {
        print("123",753,123.12);
    }


    //必须是三个点
    public static  void print(T... args) {
        for (T t : args) {
            System.out.println(t);
        }
    }
}

结果：

123
753
123.12

Process finished with exit code 0

静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。

public class StaticGenerator<T> {
    
    /**
     * 1、如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     * 2、泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，
     * 泛型方法所属的类是不是泛型类都没有关系。
     * 3、泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在初始化类时确定,所以无所谓
     */
    public static <E>  List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

细枝末节

可能合上面的有一些重复

1、泛型异常类

//异常类不能声明为泛型类，编译报错
class MyException extends Exception{
}

2、

package keyAndDifficultPoints.Generic.Minutiae;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 22:28
 * 

 * 功能描述:
 */
public class Test_Minutiae1 {
}
class Order {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT;

    public Order(){
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

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

    //如下的三个方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

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

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

    public void show(){
        //编译不通过
//        try{
//
//
//        }catch(T t){
//
//        }

    }


    /**
     * 2、泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，
     * 泛型方法所属的类是不是泛型类都没有关系。
     * 3、泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在初始化类时确定,
     * 所以无所谓
     */
    public static  List copyFromArrayToList(E[] arr){

        ArrayList list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}
class SubOrder extends Order {//SubOrder:不是泛型类


    public static  List copyFromArrayToList(E[] arr) {

        ArrayList list = new ArrayList<>();

        for (E e : arr) {
            list.add(e);
        }
        return list;

    }

}

class SubOrder1 extends Order {//SubOrder1:仍然是泛型类
}

泛型数组

package keyAndDifficultPoints.Generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 12:10
 * 

 * 功能描述: 测试泛型数组
 */
public class Test_GenericArray {

    public static void main(String[] args) {
        test02();
    }

    public static void test() {
        //编译错误
//        List[] ls = new ArrayList[10];
    }


    public static void test01() {
        //这样声明是正确的
        List[] ls = new ArrayList[10];
        ls[1] = new ArrayList();

        //这样写编译就报错了
//        ls[1].add(1);

    }

    /**
     * 下面是sun官方文档里写的。其实不用太纠结，平时泛型虽然用的多，但也不会用的这么奇葩。
     */
    public static void test02(){
        List[] lsa = new List[10]; // OK, array of unbounded wildcard type.
        Object o = lsa;
        Object[] oa = (Object[]) o;
        List li = new ArrayList();
        li.add(new Integer(3));
        oa[1] = li; // Correct.
        Integer i = (Integer) lsa[1].get(0); // OK
        System.out.println(i);
    }

    //正确
    public static void test03() {
        List[] ls = new ArrayList[10];
        ls[0] = new ArrayList();
        ls[1] = new ArrayList();

        ls[0].add("x");

    }

}

sun文档

泛型在继承方面的细节

直接看代码注释

 /*
    1. 泛型在继承方面的体现

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

       补充：类A是类B的父类，A 是 B 的父类

     */
    @Test
    public void test1() {
        /**
         * 下面是有继承关系，所以可以赋值
         */
        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

        /**
         * 下面属于并列关系，无继承关系。无法赋值
         */

        //编译不通过
//        Date date = new Date();
//        str = date;
        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
//        list1 = list2;
        /*
        反证法：
        假设list1 = list2;
           list1.add(123);导致混入非String的数据。出错。

         */

    }


    @Test
    public void test2() {

        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();

    }

泛型通配符

我们在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符，比如 T，E，K，V，？ 等等，下面来详细讲一下这些通配符。

常用的通配符

本质上都是通配符没啥区别，只不过是编码时的一种约定俗成的东西（可以说提高了代码可读性）。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个大小写字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？ 是这样约定的：

• ？ 表示不确定的 java 类型
• T (Type) 表示具体的一个java类型
• K V (Key Value) 分别代表java键值中的Key Value
• E (element) 代表Element

比较难的就是？通配符，下面就着重讲一下

’ ? '无界通配符

基本用法

List listAnimals

但是如果用通配符的话：

List listAnimals

为什么要使用通配符而不是简单的泛型呢？通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。

package keyAndDifficultPoints.Generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: youthlql-吕
 * @Date: 2020/10/15 21:25
 * 

 * 功能描述: 泛型通配符测试
 */
public class Test_Wildcard_Character {

    public static void main(String[] args) {
        List dogList = new ArrayList<>();
        test(dogList);
        test1(dogList);
    }

    static void test(List animals) {
        System.out.println("test输出:");
        for (Animal animal : animals) {
            System.out.print(animal.toString() + "-");
        }
    }

    static void test1(List animals) {
        System.out.println("test1输出:");
        for (Animal animal : animals) {
            System.out.print(animal.toString() + "-");
        }
    }


}

class Animal {
    @Override
    public String toString() {
        return "Animal";
    }
}

class Dog extends Animal {
    @Override
    public String toString() {
        return "Dog";
    }
}

test1()在编译时就会飘红

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 ），表示可以持有任何类型。像 test()方法中，限定了上界，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错，而test1()就不行。

’ ? '通配符的继承

    /*
    2. 通配符的使用
       通配符：?

       类A是类B的父类，G和G是没有关系的，二者共同的父类是：G
     */

    @Test
    public void test3() {
        List