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

目录

• 什么是泛型
• 重点概念1：泛型的作用域是在编译期间
• 重点概念2：泛型主要作用是在编译期间提供类型安全监测机制
• 泛型的使用
• 泛型类
• 泛型接口
• 泛型方法
• 泛型类中的泛型方法
• 泛型通配符
• 通配符上限
• 通配符下限
• 类型擦除
• 泛型与数组
• 小总结

什么是泛型

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());
}

类型通配符一般是使用？代替具体的类型实参，注意此处**’？’是类型实参，而不是类型形参** ，再直白点的意思就是，此处的？和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<?>

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

到此这篇关于java泛型360度无死角详细讲解的文章就介绍到这了,更多相关java泛型内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！