彻底搞懂泛型

香菜聊游戏

发布于 2021-07-15 10:04:26

5970

发布于 2021-07-15 10:04:26

文章被收录于专栏：香菜聊游戏香菜聊游戏

前言

泛型是Java中的高级概念，也是构建框架必备技能，比如各种集合类都是泛型实现的，今天详细聊聊Java中的泛型概念，希望有所收获。记得点赞，关注，分享哦。

1、泛型的概念

泛型的作用就是把类型参数化，也就是我们常说的类型参数

平时我们接触的普通方法的参数，比如public void fun(String s)；参数的类型是String，是固定的

现在泛型的作用就是再将String定义为可变的参数，即定义一个类型参数T，比如public static <T> void fun(T t);这时参数的类型就是T的类型，是不固定的

泛型常见的字母有以下：

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

这些字母随意使用，只是代表类型，也可以用单词。

2、泛型的使用

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

类的使用地方是

方法的使用地方

Java泛型类
Java泛型方法
Java泛型接口

/**
 * @author 香菜
 */
public class Player<T> {// 泛型类
    private T name;
    public T getName() { 
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
}

public class Apple extends Fruit {
    public <T> void getInstance(T t){// 泛型方法
        System.out.println(t);
    }
}

 public interface Generator<T> {
    
        public T next();
    
    }

3、泛型原理，泛型擦除

3.1 IDEA 查看字节码

1、创建Java文件，并编译，确认生成了class

2、idea ->选中Java 文件 ->View

3.2 泛型擦除原理

我们通过例子来看一下，先看一个非泛型的版本：

从字节码可以看出，在取出对象的的时候我们做了强制类型转换。

下面我们给出一个泛型的版本，从字节码的角度来看看:

在编译过程中，类型变量的信息是能拿到的。所以，set方法在编译器可以做类型检查，非法类型不能通过编译。但是对于get方法，由于擦除机制，运行时的实际引用类型为Object类型。为了“还原”返回结果的类型，编译器在get之后添加了类型转换。所以，在Player.class文件main方法主体第18行有一处类型转换的逻辑。它是编译器自动帮我们加进去的。

所以在泛型类对象读取和写入的位置为我们做了处理，为代码添加约束。

泛型参数将会被擦除到它的第一个边界（边界可以有多个，重用 extends 关键字，通过它能给与参数类型添加一个边界）。编译器事实上会把类型参数替换为它的第一个边界的类型。如果没有指明边界，那么类型参数将被擦除到Object。

4、？和 T 的区别

？使用场景和Object一样，和C++的Void 指针一样，基本上就是不确定类型，可以指向任何对象。一般用在引用。

T 是泛型的定义类型，在运行时是确定的类型。

5、super extends

通配符限定：

<? extends T>：子类型的通配符限定，以查询为主，比如消费者集合场景

<? super T>：超类型的通配符限定，以添加为主，比如生产者集合场景

super 下界通配符 ,向下兼容子类及其子孙类, T super Child 会被擦除为 Object

extends 上界通配符 ,向下兼容子类及其子孙类, T extends Parent 会被擦除为 Parent

import java.util.ArrayList;
import java.util.List;
 
class Fruit {}
class Apple extends Fruit {}
class FuShi extends Apple {}
class Orange extends Fruit {}
 
public class Aain {
  public static void main(String[] args) {
           //上界
        List<? extends Fruit> topList = new ArrayList<Apple>();
        topList.add(null);
        //add Fruit对象会报错
        //topList.add(new Fruit());
        Fruit fruit1 = topList.get(0);

        //下界
        List<? super Apple> downList = new ArrayList<>();
        downList.add(new Apple());
        downList.add(new FuShi());
        //get Apple对象会报错
        //Apple apple = downList.get(0);
  }

上界 <? extend Fruit> ，表示所有继承Fruit的子类，但是具体是哪个子类，但是肯定是Fruit

下界 <? super Apple>，表示Apple的所有父类，包括Fruit，一直可以追溯到老祖宗Object 。

归根结底可以用一句话表示，那就是编译器可以支持向上转型，但不支持向下转型。具体来讲，我可以把Apple对象赋值给Fruit的引用，但是如果把Fruit对象赋值给Apple的引用就必须得用cast。

6、注意点

1、静态方法无法访问类的泛型

可以看到Idea 提示无法引用静态上下文。

2、创建之后无法修改类型

List<Player> 无法插入其他的类型，已经确定类型的不可以修改类型

3、类型判断问题

问题：因为类型在编译完之后无法获取具体的类型，所以在运行时是无法判断类的类型。

我们可以通过下面的代码来解决泛型的类型信息由于擦除无法进行类型判断的问题：

/**
 * 判断类型
 * @author 香菜
 * @param <T>
 */
public class GenClass<T> {
    Class<?> classType;
    public GenClass(Class<?> classType) {
        this.classType = classType;
    }
    public boolean isInstance(Object object){
        return classType.isInstance(object);
    }
}

解决方案：我们通过在创建对象的时候在构造函数中传入具体的class类型，然后通过这个Class对象进行类型判断。

4、创建类型实例

问题：泛型代码中不能new T()的原因有两个，一是因为擦除，不能确定类型；而是无法确定T是否包含无参构造函数。

在之前的文章中，有一个需求是根据不同的节点配置实例化创建具体的执行节点，即根据IfNodeCfg 创建具体的IfNode.

/**
 * 创建实例
 * @author 香菜
 */
public abstract class AbsNodeCfg<T> {
    public abstract T getInstance();
}

public class IfNodeCfg extends AbsNodeCfg<IfNode>{
    @Override
    public IfNode getInstance() {
        return new IfNode();
    }
}
/**
 * 创建实例
 * @author 香菜
 */
public class IfNode {
}

解决方案：通过上面的方式可以根据具体的类型，创建具体的实例，扩展的时候直接继承AbsNodeCfg，并且实现具体的节点就可以了。