2022最新Java泛型详解(360度无死角介绍)

什么是泛型

Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了 编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是 参数化类型，也就是所操作的数据类型被指定为一个参数。

重点概念1：泛型的作用域是在编译期间

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
   System.out.println("泛型测试类型相同");
}

重点概念2：泛型主要作用是在编译期间提供类型安全监测机制

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
   String item = (String)arrayList.get(i);
   System.out.println("泛型测试item = " +item);
}

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList可以存放任意类型，例子中首次添加了一个Sring类型，那么arrayList 再使用时都以String的方式使用，此时再次添加一个Integer类型的变量100，arrayList 只能尝试将Integer类型的变量100转为String，因此程序报错；

为了解决类似这样的问题，泛型应运而生，我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

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

综上可知：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

泛型类

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

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
   //key这个成员变量的类型为T,T的类型由外部指定  
   private T key;

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

public <T,K> T showKeyName(Generic<T> container){
       System.out.println("container key :" + container.getKey());
       T test = container.getKey();
       return test;
   }

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

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

泛型接口

//定义一个泛型接口
public interface Generator<T> {
   public T next();
}

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

/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
   @Override
   public T next() {
       return null;
   }
}

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

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

private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

@Override
   public String next() {
       Random rand = new Random();
       return fruits[rand.nextInt(3)];
   }
}

泛型方法

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

例如上述Generic类中两个方法

public T getKey(){
    return key;
}

虽然在方法中使用了泛型，但是这并不是一个泛型方法。这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。所以在这个方法中才可以继续使用 T 这个泛型。

public <T,K> T showKeyName(Generic<T> container){
   System.out.println("container key :" + container.getKey());
   T test = container.getKey();
   return test;
}

这才是一个真正的泛型方法。 首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T这个T可以，出现在这个泛型方法的任意位置，泛型的数量也可以为任意多个

泛型类中的泛型方法

public 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<T>{
       public void show_1(T t){
           System.out.println(t.toString());
       }

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

//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
       public <T> void show_2(T t){
           System.out.println(t.toString());
       }
   }

public static void main(String[] args) {
       Apple apple = new Apple();
       Person person = new Person();

GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
       //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);
   }
}

泛型通配符

Ingeter是Number的一个子类，Generic与Generic实际上是相同的一种基本类型。那么问题来了，在使用Generic作为形参的方法中，能否使用Generic的实例传入呢？在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Generic这个泛型类继续看下面的例子：

public void showKeyValue1(Generic<Number> obj){
   Log.d("泛型测试","key value is " + obj.getKey());
}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);
showKeyValue(gInteger);

showKeyValue(gInteger);这个方法编译器会为我们报错：

Generic<java.lang.Integer> cannot be applied to Generic<java.lang.Number>

而且如果我们用重载的思维再定义一个Generic<java.lang.Integer>类型的方法

public static void showKeyValue1(Generic<Integer> obj){
       System.out.println("泛型测试,key value is " + obj.getKey());

System.out.println("泛型测试类型相同");
   }

public static void showKeyValue1(Generic<Integer> obj){
       System.out.println("泛型测试,key value is " + obj.getKey());

System.out.println("泛型测试类型相同");
   }

会报错重载异常

'showKeyValue1(Generic<Integer>)' is already defined in 'com.wzh.demo.test.FruitGenerator'

这其实是印证了上述的结论：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型，也就是Generic<java.lang.Integer>和Generic<java.lang.Number>本质都是Generic，但编译期间方法入参必须指定的泛型类，因为同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

解决方案，使用泛型通配符?

public void showKeyValue1(Generic<?> obj){
   Log.d("泛型测试","key value is " + obj.getKey());
}

类型通配符一般是使用？代替具体的类型实参，注意此处**&rsquo;？&rsquo;是类型实参，而不是类型形参** ，再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。当具体类型不确定的时候。那么可以用 ? 通配符来表未知类型。

通配符上限

//结构
public class XxxClass<T extend XxxClass>

//案例
public void showKeyValue1(Generic<? extend Number> obj){
   Log.d("泛型测试","key value is " + obj.getKey());
}

此时限定传参的泛型类只能是Number或者Number的子类

通配符下限

//结构
public class XxxClass<T super XxxClass>

//案例
public void showKeyValue1(Generic<? super Number> obj){
   Log.d("泛型测试","key value is " + obj.getKey());
}

此时限定传参的泛型类只能是Number或者Number的父类

类型擦除

public class Erasure<T>{
   //key这个成员变量的类型为T,T的类型由外部指定  
   private T key;

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

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

public <T extends List> T show(T t){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
       return t;
   }

}

我们从程序运行期间来看

public static void main(String[] args) {
       Erasure<Number> gNumber = new Erasure<Number>(456);

Class<? extends Erasure> aClass = gNumber.getClass();
       Field[] declaredFields = aClass.getDeclaredFields();
       for (Field declaredField : declaredFields) {
           System.out.println(declaredField.getName() + ":" +declaredField.getType().getSimpleName());
       }
   }

结果

key:Object

如果我们给泛型加一个类型通配符上限

public class Erasure<T extends Number>{....}

那么，打印结果就是

key:Number

且对应的方法

如果是接口类型的泛型

interface Info<T> {

public T info(T t);
}

public class InfoImpl implements Info<Integer>{

@Override
   public Integer info(Integer var) {
       return var;
   }

public static void main(String[] args) {
       Class<InfoImpl> infoClass = InfoImpl.class;
       Method[] declaredMethods = infoClass.getDeclaredMethods();
       for (Method declaredMethod : declaredMethods) {
           System.out.println(declaredMethod.getName() + ":" + declaredMethod.getReturnType().getSimpleName());
       }
   }
}

打印结果

main:void
info:Integer
info:Object

个人备注一个疑问点，如上图所示类型擦除后会生成一个Integer和Object类型的info方法，但为何我通过反射调用Object类型的info方法时候会有报错呢？

public class InfoImpl implements Info<Integer>{

@Override
   public Integer info(Integer var) {
       return var;
   }

public static void main(String[] args) throws IllegalAccessException, InstantiationException, InvocationTargetException {
       Class<InfoImpl> infoClass = InfoImpl.class;
       Method[] declaredMethods = infoClass.getDeclaredMethods();
       for (Method declaredMethod : declaredMethods) {
           System.out.println("methodNameAndType:" +declaredMethod.getName() + ":" + declaredMethod.getReturnType().getSimpleName());
           if(declaredMethod.getReturnType().getSimpleName().equals("Object")){
               InfoImpl info = infoClass.newInstance();
//                System.out.println("methodName:"  +declaredMethod.getName());
               Arrays.stream(declaredMethod.getParameterTypes()).forEach(param -> {
                   System.out.println("param:" +  param);
               });
               System.out.println("method return :" +declaredMethod.getReturnType());
               String str= "abc";
               Object invoke = declaredMethod.invoke(info, str);
               System.out.println(invoke);
           }
       }
   }
}

易混点强调：由于泛型擦除机制，T仅仅是当做一种符号，即占位符去使用，没有实际意义，所以如果你试图同T t = new T();实例化T类型的对象是通不过编译的

class GenericsA<T>
{
   T t = new T(); // Error
}

但是我们可以通过反射来完成这一需求

public T createT(Class<T> tClass) throws IllegalAccessException, InstantiationException {
    return tClass.newInstance();
}

泛型与数组

可以声明带泛型的数据引用，但不能直接创建带泛型的数组对象

小总结

泛型的作用域：编译期间；

泛型的作用：

• 编译时提供类型安全监测机制，最典型的就是各种容器类如：List、Set、Map，通过泛型在编译期间限制添加元素的类型

• 增强代码规范性&复用性，例如设计模式模板方法模式结合泛型来使用，在模板方法中使用泛型，可以增强模板方法的复用性

泛型的类型问题：

• 泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型，可以理解为泛型就是一种作用在编译期的占位符，过了编译期，运行期的类型擦除机制会完全擦除泛型类的影响

• 同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的，参考以下报错来理解

Generic<java.lang.Integer>  cannot be applied to Generic<java.lang.Number>

但我们可以通过泛型通配符Generic<?>

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

来源：https://blog.csdn.net/wwwwwww31311/article/details/127149313