Java—— 泛型详解

泛型概述

泛型是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。
泛型的格式：<数据类型>
注意：泛型只能支持引用数据类型。

泛型的好处

没有泛型的时候，可以往集合中添加任意类型的数据，默认将集合中所有元素的数据类型都提升为Object类型，但是在获取数据的时候，数据都是Object类型，所以无法直接使用原来类型的特有方法，需要进行强转，如果不知道该强转成什么数据类型就没办法了。
此时推出了泛型，可以在添加数据的时候就把类型进行统一。
而且我们在获取数据的时候，也省的强转了，非常的方便。 

泛型的细节

1.泛型中不能写基本数据类型
2.指定泛型的具体类型的集合，添加数据时，可以添加该类类型或者其子类类型的数据
3.如果不写泛型，类型默认是Object 

泛型的分类

在类后面定义泛型为泛型类
在方法上面定义泛型为泛型方法
在接口后面定义泛型为泛型接口 

泛型类

使用场景

当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

格式

修饰符 class 类名 <类型> {

        ...

}

举例

public class MyArrayList <E> {

        ...
}

此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，常用T、E、K、V字母表示，创建该类对象时，E就确定类型

如果该类要使用多种类型的数据，可在<>中写多种变量通过逗号分隔，例如<E,T,K>

代码演示 

要求：定义一个类实现ArrayList中的部分方法 

import java.util.Arrays;

//定义一个类实现ArrayList中的部分方法
public class MyArrayList<E>{

    //成员变量
    private Object[] obj = new Object[10];
    private int size;

    public MyArrayList() {
    }

    //添加元素方法
    public boolean add(E e){
        obj[size] = e;
        size++;
        return true;
    }

    //get方法
    public E get(int i){
        return (E)obj[i];
    }

    @Override
    public String toString() {
        return obj.toString();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        MyArrayList<String> mal1 = new MyArrayList<>();
        mal1.add("aaa");
        mal1.add("bbb");
        System.out.println(mal1.get(1));//bbb

        MyArrayList<Integer> mal2 = new MyArrayList<>();
        mal2.add(1);
        mal2.add(2);
        System.out.println(mal2.get(1));//2
    }
}

泛型方法

使用场景

当一个方法，某个变量的数据类型不确定时，就可以定义带有泛型的方法

格式

修饰符 <类型> 返回值类型 方法名(类型 变量名){

        ...

}

举例

public <E> void show(E e){

        ...

}

调用该方法时E就确定类型

代码演示

定义一个工具类:ListUtil，类中定义一个静态方法addAll，用来添加多个集合的元素。

import java.util.ArrayList;
//定义一个工具类:ListUtil
//类中定义一个静态方法addAll，用来添加多个集合的元素。
public class ListUtil {
    private ListUtil() {
    }

    public static <E> void addAll1(ArrayList<E> list, E e1, E e2) {
        list.add(e1);
        list.add(e2);
    }

    //参数个数不确定时使用E...e
    public static <E> void addAll2(ArrayList<E> list, E... e) {
        for (E element : e) {
            list.add(element);
        }
    }

}

 测试类

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ListUtil.addAll1(list1, "aaa", "bbb");
        System.out.println(list1);//[aaa, bbb]

        ArrayList<Integer> list2 = new ArrayList<>();
        ListUtil.addAll2(list2, 1, 2, 3, 4);
        System.out.println(list2);//[1, 2, 3, 4]
    }
}

细节

泛型类和泛型方法泛型方法都能解决方法中形参类型不确定的问题

区别：
使用类名后面定义的泛型：所有方法都能用
在方法申明上定义自己的泛型：只有本方法能用

泛型接口

使用场景

定义在接口名后面，表示接口实现类的类型

如何使用一个带泛型的接口

方式1:

实现类给出具体类型

方式2:

实现类延续泛型，创建对象时再确定

泛型的通配符

泛型不具备继承性，但是数据具备继承性。

指定泛型的具体类型的集合，添加数据时，可以添加该类类型或者其子类类型的数据

但是调用方法时，形参的泛型里面写的是什么类型，那么只能传递什么类型的数据

此时我们就可以使用泛型的通配符:
?也表示不确定的类型
? extends E：表示可以传递E或者E所有的子类类型
? super E：表示可以传递E或者E所有的父类类型 

练习

 

测试类中定义一个方法用于饲养动物
public static void keepPet(ArrayList<???> list){
        //遍历集合，调用动物的eat方法
}
要求1:该方法能养所有品种的猫，但是不能养狗
要求2:该方法能养所有品种的狗，但是不能养猫
要求3:该方法能养所有的动物，但是不能传递其他类型

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<PersianCat> list1 = new ArrayList<>();
        ArrayList<LiHuaCat> list2 = new ArrayList<>();
        ArrayList<TeddyDog> list3 = new ArrayList<>();
        ArrayList<HuskyDog> list4 = new ArrayList<>();
        keepPet(list1);
        keepPet(list2);
        keepPet(list3);
        keepPet(list4);
    }

    //测试类中定义一个方法用于饲养动物
    //要求1:该方法能养所有品种的猫，但是不能养狗
    //public static void keepPet(ArrayList<? extends Cat> list) {}

    //要求2:该方法能养所有品种的狗，但是不能养猫
    //public static void keepPet(ArrayList<? extends Dog> list) {}

    //要求3:该方法能养所有的动物，但是不能传递其他类型
    public static void keepPet(ArrayList<? extends Animal> list) {}
}    


    abstract class Animal {
        public abstract void eat();
    }

    abstract class Cat extends Animal {
    }

    abstract class Dog extends Animal {
    }

    class PersianCat extends Cat {
        @Override
        public void eat() {
            System.out.println("波斯猫吃东西");
        }
    }

    class LiHuaCat extends Cat {
        @Override
        public void eat() {
            System.out.println("狸花猫吃东西");
        }
    }

    class TeddyDog extends Dog {
        @Override
        public void eat() {
            System.out.println("泰迪狗吃东西");
        }
    }

    class HuskyDog extends Dog {
        @Override
        public void eat() {
            System.out.println("哈士奇吃东西");
        }
    }