泛型概述
泛型是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("哈士奇吃东西");
}
}
