Java泛型介绍

归零星辰

已于 2022-03-08 10:02:05 修改

阅读量368

点赞数 1

分类专栏：学习笔记文章标签： java 后端

于 2022-03-07 20:05:50 首次发布

本文链接：https://blog.csdn.net/wmdxdbk/article/details/123139442

版权

学习笔记专栏收录该内容

3 篇文章 3 订阅

订阅专栏

1 什么是泛型

1.1 不使用泛型时的问题

JAVA推出泛型以前，可以通过构建一个元素类型为Object的集合，来存储任意的数据类型对象，但在使用该集合的过程中，需要明确知道存储每个元素的数据类型，否则很容意引发ClassCastException异常。
如下代码所示：

        ArrayList list = new ArrayList();
        list.add("java");
        list.add(90);
        list.add(false);

        for (int i = 0; i < list.size(); i ++){
            Object o = list.get(i);
            String str = (String) o;
            System.out.println(str);
        }

运行后报错信息：
在这里插入图片描述

1.2 泛型的概念

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

		/*
        泛型：
        编译期间检查类型
        减少了数据类型转换
         */
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("hello");
        arrayList.add("java");
        arrayList.add("world");

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

1.3 泛型的好处

类型安全
消除了强制类型的转换

2 泛型类、接口

2.1 泛型类

定义语法

class 类名称 <泛型标识，泛型标识，...>{
 	private 泛型标识 变量名：
 	...
}

常用的泛型标识： T、E、K、V

使用语法

类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

Java1.7以后，后面的<>中的具体的数据类型可以省略不写。

类名<具体的数据类型> 对象名 = new 类名<>();

泛型类定义与使用示例：

/**
 * 泛型类的定义
 * @param <T> 泛型标识——类型形参
 *           T 创建对象的时候来指定具体的数据类型
 */
public class Generic<T> {
    //T 是由外部使用类的时候来指定
    private T key;

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

    public T getKey() {
        return key;
    }

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

    @Override
    public String toString() {
        return "Generic{" +
                "key=" + key +
                '}';
    }
}

public class MainClass {
    public static void main(String[] args) {
        //泛型类在创建对象的时候，来指定操作的具体数据类型
        Generic<String> strGeneric = new Generic<>("abc");
        String key1 = strGeneric.getKey();
        System.out.println("key1:"+key1);

        Generic<Integer> intGeneric = new Generic<>(100);
        int key2 = intGeneric.getKey();
        System.out.println("key2:"+key2 );

        //泛型类在创建对象的时候，没有指定类型，将按照Object类型来操作
        Generic generic = new Generic("ABC");
        Object key3 = generic.getKey();
        System.out.println("key3:"+key3);

        //泛型类 不支持基本数据类型
        //Generic<int> generic1 = new Generic<int>(100);

        //同一泛型类，根据不同的数据类型创建的对象本质上是同一类型
        System.out.println(strGeneric.getClass());
        System.out.println(intGeneric.getClass());
        System.out.println(strGeneric.getClass() == intGeneric.getClass());
    }
}

运行结果：
在这里插入图片描述

泛型类注意事项
1、泛型类，如果没有指定具体的数据类型，此时，操作类型是Object。
2、泛型的类型参数只能是类类型，不能是基本数据类型。
3、泛型类在逻辑上可以看成是多个不同的类型，但实际上都是相同类型。

2.2 从泛型类派生子类

如果子类也是泛型类，子类和父类的泛型类型要一致

class ChildGeneric<T> extends Generic<T>

如果子类不是泛型类，父类要明确泛型的数据类型

class ChildGeneric extends Generic<String>

泛型类派生子类示例：

public class Parent<E> {
    private E value;

    public E getValue() {
        return value;
    }

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

/**
 * 泛型类派生子类，如果子类也是泛型类，那么子类的泛型标识要和父类一致。
 * @param <T>
 */
public class ChildFirst<T> extends Parent<T> {

    @Override
    public T getValue() {
        return super.getValue();
    }
}

/**
 * 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
 */
public class ChildSecond extends Parent<Integer>{

    @Override
    public Integer getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }
}

public class Test {
    public static void main(String[] args) {
        ChildFirst<String> childFirst = new ChildFirst<>();
        childFirst.setValue("abc");
        String valueFirst = childFirst.getValue();
        System.out.println(valueFirst);

        ChildSecond childSecond = new ChildSecond();
        childSecond.setValue(100);
        Integer valueSecond = childSecond.getValue();
        System.out.println(valueSecond);
    }
}

2.3 泛型接口

泛型接口的定义语法

interface 接口名称<泛型标识，泛型标识，...>{
	泛型标识 方法名();
	.....
}

泛型接口的使用
1、实现类不是泛型类，接口要明确数据类型。
2、实现类也是泛型类，实现类和接口的泛型类型要一致。

泛型接口的定义与使用示例：

/**
 * 泛型接口
 * @param <T>
 */
public interface Generator<T> {
    T getKey();
}

/**
 * 实现泛型接口的类，如果不是泛型类，需要明确实现泛型接口的数据类型
 */
public class Apple implements Generator<String> {
    @Override
    public String getKey() {
        return "apple";
    }
}

/**
 * 泛型接口的实现类，如果是一个泛型类，那么要保证实现接口的泛型类的泛型标识包含泛型接口的泛型标识
 * @param <T>
 * @param <E>
 */
public class Pear<T,E> implements Generator<T>{

    private T key;
    private E value;

    public Pear(T key,E value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public E getValue(){
        return value;
    }
}

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        String key = apple.getKey();
        System.out.println(key);

        Pear<String,Integer> pear = new Pear<>("count",100);
        String pearKey = pear.getKey();
        Integer pearValue = pear.getValue();
        System.out.println(pearKey+"="+pearValue);
    }
}

运行结果：
在这里插入图片描述

3 泛型方法

3.1 泛型方法语法

修饰符 <T,E,...> 返回值类型 方法名(形参列表){
	方法体...
}

public与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
只有声明了 <T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
<T>表明该方法将使用泛型类形T，此时才可以在方法中使用泛型类型T。
与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

泛型方法定义与使用示例：

public class ProductGetter<T> {
    static Random random = new Random();

    /**
     * 定义泛型方法
     * @param list 参数
     * @param <T> 泛型标识，具体类型，由调用方法的时候来指定。
     * @return
     */
    public <T> T getProduct(ArrayList<T> list){
        return list.get(random.nextInt(list.size()));
    }

    /**
     * 静态的泛型方法，采用多个泛型类型
     * @param t
     * @param e
     * @param k
     * @param <T>
     * @param <E>
     * @param <K>
     */
    public static <T,E,K> void printType(T t,E e,K k){
        System.out.println(t+"\t"+t.getClass().getSimpleName());
        System.out.println(e+"\t"+e.getClass().getSimpleName());
        System.out.println(k+"\t"+k.getClass().getSimpleName());
    }

	/**
     * 泛型可变参数的定义
     * @param e
     * @param <E>
     */
    public static <E> void print(E... e){
        for (int i = 0; i < e.length; i++) {
            System.out.println(e[i]);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        ProductGetter<Integer> productGetter = new ProductGetter<>();
        ArrayList<String> strList = new ArrayList<>();
        strList.add("product01");
        strList.add("product02");
        strList.add("product03");
        //泛型方法的调用，类型是通过调用方法的时候来指定
        String product1 = productGetter.getProduct(strList);
        System.out.println(product1+"\t"+product1.getClass().getSimpleName());

        ArrayList<Integer> intList = new ArrayList<>();
        intList.add(100);
        intList.add(200);
        intList.add(300);
        Integer product2 = productGetter.getProduct(intList);
        System.out.println(product2+"\t"+product2.getClass().getSimpleName());

        //调用多个泛型类型的静态泛型方法
        System.out.println("--------------");
        ProductGetter.printType(100,"java",true);
        
		//可变参数的泛型方法的调用
        System.out.println("--------------");
        ProductGetter.print(1,2,3,4,5);
        System.out.println("--------------");
        ProductGetter.print("a","b","c");
    }
}

运行结果:
在这里插入图片描述

3.2 泛型方法总结

泛型方法能使方法独立于类而产生变化。
如果static方法要使用泛型能力，就必须使其成为泛型方法。

4 类型通配符

4.1 什么是类型通配符

类型通配符一般是使用 ? 代替具体的类型实参。
类型通配符是类型实参，而不是类型形参。

示例如下：

public class Box<E> {
    private E first;

    public E getFirst() {
        return first;
    }

    public void setFirst(E first) {
        this.first = first;
    }
}

/**
 * 类型通配符
 */
public class Test {
    public static void main(String[] args) {
        Box<Number> box1 = new Box<>();
        box1.setFirst(100);
        showBox(box1);

        Box<Integer> box2 = new Box<>();
        box2.setFirst(200);
        showBox(box2);
    }

    public static void showBox(Box<?> box){
        Object first = box.getFirst();
        System.out.println(first);
    }
}

运行结果：
在这里插入图片描述

4.2 类型通配符的上限

语法

类/接口<? extends 实参类型>

类型通配符上限要求该泛型的类型，只能是实参类型，或实参类型的子类类型。

类型通配符上限示例:

public class Animal {
}

public class Cat extends Animal{
}

public class MiniCat extends Cat {
}

/**
 * 类型通配符
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<MiniCat> miniCats = new ArrayList<>();

        //报错 cats中只能通过addAll传入Cat或Cat的子类
//        cats.addAll(animals);
        cats.addAll(cats);
        cats.addAll(miniCats);

//        showAnimal(animals);
        showAnimal(cats);
        showAnimal(miniCats);
    }

    /**
     * 泛型上限通配符，传递的集合类型，只能是Cat或Cat的子类类型
     * @param list
     */
    public static void showAnimal(ArrayList<? extends Cat> list){

        //报错 list无法填充元素
//        list.add(new Animal());
//        list.add(new Cat());
//        list.add(new MiniCat());
//        list.addAll(new ArrayList<Cat>());

        for (int i = 0; i < list.size(); i++) {
            Cat cat = list.get(i);
            System.out.println(cat);
        }
    }
}

如上例子中，main方法中调用showAnimal方法，所传的参数只能是Cat或Cat的子类类型MiniCat，传入Animal类型则会报错。
同时，可以发现ArrayList中的addAll方法中的传入的参数，也是可以传Cat和MiniCat，传入Animal会报错。原因也是相同的，可以查看addAll方法的源码：
在这里插入图片描述

4.3 类型通配符的下限

语法

类/接口<? super 实参类型>

类型通配符下限要求该泛型的类型，只能是实参类型，或实参类型的父类类型。

示例如下:

/**
 * 类型通配符下限
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<MiniCat> miniCats = new ArrayList<>();

        showAnimal(animals);
        showAnimal(cats);
//        showAnimal(miniCats);
    }

    /**
     * 类型通配符下限，要求集合只能是Cat或Cat的父类类型
     * @param list
     */
    public static void showAnimal(ArrayList<? super Cat> list){

        //list中可以填充Cat或Cat的子类类型
        list.add(new Cat());
        list.add(new MiniCat());

        for (Object o : list){
            System.out.println(o);
        }
    }
}

上面的例子中，main方法中调用showAnimal方法，所传的参数只能是Cat或Cat的父类类型Animal，传入MiniCat类型则会报错。

再来一个示例：

public class Animal {

    public String name;

    public Animal(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Cat extends Animal{

    public int age;
    
    public Cat(String name,int age) {
        super(name);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class MiniCat extends Cat {

    public int level;

    public MiniCat(String name, int age,int level) {
        super(name, age);
        this.level = level;
    }

    @Override
    public String toString() {
        return "MiniCat{" +
                "level=" + level +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

/**
 * 类型通配符下限的使用
 */
public class Test {
    public static void main(String[] args) {
        TreeSet<Cat> treeSet1 = new TreeSet<>(new Comparator1());
        treeSet1.add(new Cat("liu",35));
        treeSet1.add(new Cat("zhang",30));
        treeSet1.add(new Cat("wang",29));
        treeSet1.add(new Cat("sun",34));
        for (Cat cat : treeSet1) {
            System.out.println(cat);
        }

        System.out.println("--------------------------------");

        TreeSet<Cat> treeSet2 = new TreeSet<>(new Comparator2());
        treeSet2.add(new Cat("liu",35));
        treeSet2.add(new Cat("zhang",30));
        treeSet2.add(new Cat("wang",29));
        treeSet2.add(new Cat("sun",34));
        for (Cat cat : treeSet2) {
            System.out.println(cat);
        }

        //报错，参数只能是Cat或Cat的父类类型
//        TreeSet<Cat> treeSet3 = new TreeSet<>(new Comparator3());

    }
}
class Comparator1 implements Comparator<Animal>{
    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.name.compareTo(o2.name);
    }
}

class Comparator2 implements Comparator<Cat>{
    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.age - o2.age;
    }
}

class Comparator3 implements Comparator<MiniCat>{
    @Override
    public int compare(MiniCat o1, MiniCat o2) {
        return o1.level - o2.level;
    }
}

运行结果如下图：
在这里插入图片描述
可以看到，当TreeSet的参数为Comparator1比较器时，Cat对象根据name来排序。当TreeSet的参数为Comparator2比较器时，Cat对象根据age来排序。即TreeSet的比较器参数可以传入Cat和Cat的父类类型，但当传入Cat的子类类型MiniCat时则会报错，原因就是TreeSet的这个构造方法的参数类型使用了通配符下限的限制，下图为源码：
在这里插入图片描述

5 类型擦除

5.1 概念

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好的和之前版本的代码兼容，那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为类型擦除。
示例：

/**
 * 泛型擦除
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> intList = new ArrayList<>();
        ArrayList<String> strList = new ArrayList<>();

        System.out.println(intList.getClass().getSimpleName());
        System.out.println(strList.getClass().getSimpleName());

        System.out.println(intList.getClass() == strList.getClass());
    }
}

运行结果：
在这里插入图片描述可以看到，虽然在编译阶段分别创建了两个不同类型的List，但在编译之后intList和strList的类型信息被完全擦除掉了，他们都是ArrayList类型。

5.2 类型擦除的几种情况

无限制类型擦除
如下图，在编译的过程中，T都被Object类型代替了。
示例如下：

public class Erasure<T> {
    private T key;

    public T getKey() {
        return key;
    }

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

public class Test {
    public static void main(String[] args) {
        Erasure<Integer> erasure = new Erasure<>();
        //利用反射，获取Erasure类的字节码文件的class类对象
        Class<? extends Erasure> clz = erasure.getClass();
        //获取所有的成员变量
        Field[] declareFields = clz.getDeclaredFields();
        for (Field field : declareFields) {
            //打印成员变量的名称和类型
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());
        }
    }
}

运行结果：
在这里插入图片描述

有限制类型擦除

如下图，泛型类指定了类型上限，在编译过程中，T被类型的上限Number代替了。
在这里插入图片描述示例如下：

public class Erasure<T extends Number> {
    private T key;

    public T getKey() {
        return key;
    }

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

public class Test {
    public static void main(String[] args) {
        Erasure<Integer> erasure = new Erasure<>();
        //利用反射，获取Erasure类的字节码文件的class类对象
        Class<? extends Erasure> clz = erasure.getClass();
        //获取所有的成员变量
        Field[] declareFields = clz.getDeclaredFields();
        for (Field field : declareFields) {
            //打印成员变量的名称和类型
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());
        }
    }
}

运行结果：
在这里插入图片描述

擦除方法中类型定义的参数

如下图，泛型方法指定了类型上限，在编译过程中，T被类型的上限Number代替了。
在这里插入图片描述示例如下：

public class Erasure<T extends Number> {
    private T key;

    public T getKey() {
        return key;
    }

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

    /**
     * 泛型方法
     * @param t
     * @param <T>
     * @return
     */
    public <T extends List> T show(T t){
        return t;
    }
}

public class Test {
    public static void main(String[] args) {
        Erasure<Integer> erasure = new Erasure<>();
        //利用反射，获取Erasure类的字节码文件的class类对象
        Class<? extends Erasure> clz = erasure.getClass();
        //获取所有的方法
        Method[] declareMethods = clz.getDeclaredMethods();
        for (Method method : declareMethods) {
            //打印方法名和返回值类型
            System.out.println(method.getName() + ":" + method.getReturnType().getSimpleName());
        }
    }
}

运行结果：
在这里插入图片描述

桥接方法
示例如下：

/**
 * 泛型接口
 * @param <T>
 */
public interface Info<T> {
    T info(T t);
}

public class InfoImpl implements Info<Integer> {

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

public class Test {
    public static void main(String[] args) {
        Class<InfoImpl> infoClass = InfoImpl.class;
        //获取所有的方法
        Method[] infoImplMethods = infoClass.getDeclaredMethods();
        for (Method method : infoImplMethods) {
            //打印方法名和返回值类型
            System.out.println(method.getName() + ":" + method.getReturnType().getSimpleName());
        }
    }
}

运行结果：
在这里插入图片描述可以看到，实现类多出了保持接口和类的实现关系的桥接方法，返回值类型是Object

6 泛型与数组

6.1 泛型数组的创建

可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象。
示例：

public class Test {
    public static void main(String[] args) {
        ArrayList<String>[] listArr = new ArrayList[5];

        ArrayList<String> strList = new ArrayList<>();
        strList.add("abc");
        listArr[0] = strList;
        String s = listArr[0].get(0);
        System.out.println(s);
    }
}

运行结果：
在这里插入图片描述

可以通过java.lang.reflect.Array的newInstance(Class,int)创建T[ ]数组。
示例：

public class Fruit<T> {
    private T[] array;

    public Fruit(Class<T> clz,int length){
        //通过Array.newInstance创建泛型数组
        array = (T[])Array.newInstance(clz,length);
    }

    /**
     * 填充数组
     * @param index
     * @param item
     */
    public void put(int index,T item){
        array[index] = item;
    }

    /**
     * 获取数组元素
     * @param index
     * @return
     */
    public T get(int index){
        return array[index];
    }

    public T[] getArray(){
        return array;
    }
}

public class Test1{
    public static void main(String[] args) {
        Fruit<String> fruit = new Fruit<>(String.class,3);
        fruit.put(0,"苹果");
        fruit.put(1,"西瓜");
        fruit.put(2,"香蕉");
        System.out.println(Arrays.toString(fruit.getArray()));
        String s = fruit.get(2);
        System.out.println(s);
    }
}

运行结果：
在这里插入图片描述

7 泛型和反射

7.1 反射常用的泛型类

Class<T>
Constructor<T>

示例：

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

不使用泛型时，通过反射获得Object类型，后续使用还需进行类型转换：

public class Test {
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
        Constructor constructor = personClass.getConstructor();
        Object o = constructor.newInstance();
    }
}

通过泛型和反射可直接获得Person类，使得编写反射程序更加方便：

public class Test {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;
        Constructor<Person> constructor = personClass.getConstructor();
        Person person = constructor.newInstance();
    }
}

归零星辰

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java泛型介绍

泛型1、泛型概述JAVA推出泛型以前，可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，但在使用该集合的过程中，需要明确知道存储每个元素的数据类型，否则很任意引发ClassCastException异常。...
复制链接

扫一扫