作用:
是 jdk5 中引入的特性,可以在编译阶段 约束 操作的数据类型,并进行检查。
格式:
<数据类型>
注意泛型只能支持引用数据类型,基本数据类型可转成对应的包装类。
问题:
在没有泛型的时候,集合如何存储数据?
结论:如果我们没有给集合类型,默认数据为 Object 类型。
即可以添加任意类型的数据
如图:
等等;
弊端 1:
我们在获取集合内的数据时,无法使用它里面的特有方法。
如,以下情况:
其实这是构成了一种多态结构,而在讲解多态调用成员的特点中说过
调用成员方法,编译看左边,运行看右边
需要将 Object 强转成 String 才可以调用。
此时推出了泛型,
可以再添加数据时把类型进行统一。
而且我们在获取数据的时候,也省的强转了,非常方便。
如图:
好处
总的来说泛型的好处:
- 统一数据类型。
- 把运行时期的问题提前到了编译期间,避免了强制类型转换可能出现的异常,因为在编译阶段类型就能确定下来
- 扩展:
- 泛型擦除(Type Erasure)是Java中实现泛型的一种方式,泛型类型信息在编译时会被擦除,使得在运行时无法获取泛型的具体类型信息。这可能会导致一些限制和需要额外注意的地方,比如无法直接创建泛型类型的实例。
- 例如:
- 泛型擦除(Type Erasure)是Java中实现泛型的一种方式,泛型类型信息在编译时会被擦除,使得在运行时无法获取泛型的具体类型信息。这可能会导致一些限制和需要额外注意的地方,比如无法直接创建泛型类型的实例。
泛型细节:
- 泛型中不能写基本数据类型
- 指定泛型的具体类型后,传递数据时,可以传入该类类型或者其子类类型
- 如果不写泛型,类型默认是Object
泛型的应用:
泛型类:在类名后用
使用场景:当一个类中,某个变量的数据类型不确定时,就可以定义带有泛型的类
格式:
这里的 E 是用来记录数据类型的,可以写成:T、E、K、V 等等
为了方便理解,在编写泛型类时,可以把自己想想成一个大佬,你需要考虑到使用这个类的人 是如何 使用这个类的。
现在我们就来实际体会下:
/*
泛型类*/
public class MYArrayList <E> {//ArrayList底层是一个Object数组Object[]obj=new Object[10];//集合长度int size;//add方法,其中E表示不确定的类型,e变量名public boolean add(E e){obj[size]=e;//size既表示长度,又表示下一元素存入位置size++;//添加后长度++return true;}//在底层是Object类型,在获取时强转为测试类中泛型指定的类型public E get(int index){return (E) obj[index];}@Overridepublic String toString(){return Arrays.toString(obj);}
}
测试类
public static void main(String[] args) {//创建对象,指定类型StringMYArrayList<String> list = new MYArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");System.out.println(list.get(0));System.out.println(list);//-----------------------,//创建对象,指定类型IntegerMYArrayList<Integer> list1 = new MYArrayList<>();list1.add(123);list1.add(123);list1.add(123);System.out.println(list1.get(0));System.out.println(list1);}
控制台:
aaa
[aaa, bbb, ccc, null, null, null, null, null, null, null]
123
[123, 123, 123, null, null, null, null, null, null, null]
泛型方法:修饰符后声明泛型
应用场景:方法形参类型不确定时,有两种情况
- 使用类名候命定义的泛型----所有方法都能用
- 在方法的修饰符后声明自己的泛型------只有本方法能用
格式:public static
用一个例子来理解:
//在工具类 ListUtil 类中定义一个静态方法addAll,用来添加多个集合元素。
//工具类
public class ListUtil {//私有化构造方法,不让外界创造对象private ListUtil() {}//类中定义一个静态方法add A11,用来添加多个集合的元素。
// 参数一:集合
// 参数二:要添加的元素public static <E>void addAll1(ArrayList<E> list,E e1,E e2,E e3){list.add(e1);list.add(e2);list.add(e3);}/* public static <E>void addAll2(ArrayList<E> list,E...e){for (E element:e){list.add(element);
} */}
注释部分: E…e 表示可变参数,用 E[] 来存储,只能通过遍历来获取元素,后面再说
测试类:
//创建集合对象,规定泛型为String
ArrayList<String>list1=new ArrayList<>();ListUtil.addAll1(list1,"a","b","c");
System.out.println(list1);//创建集合对象,规定泛型String
ArrayList<Integer>list2=new ArrayList<>();ListUtil.addAll1(list2,1,2,3);
System.out.println(list2);
若没限定,默认 Object 型
泛型接口:在接口名后用
格式:
重点:如何使用来个带泛型的接口?
-
在实现接口的类中给出具体类型
-
在实现类中延续泛型,创建实现类的对象时再确定类型
-
在实现接口的类中给出具体类型:
这是一个泛型接口
现在我们创建一个类来实现接口,并直接给出具体类型
此时实现类中的 add 方法形参直接确定类型为 String
所以在测试类中创建实现类的对象后 只能添加 String类型
- 在实现类中延续泛型,创建实现类的对象时再确定类型
现在我们创建一个类来实现 List 接口,但延续泛型
此时实现类中的 add 方法形参仍是泛型
创建实现类的对象并确定类型
泛型的通配符:
严格的泛型类型系统使用起来并不那么令人愉快,
“解决方案”:通配符类型。
- <?>表示 和 一样也表示不确定的类型,但是?不需要提前定义,而 E 需要提前定义
- ?extends E:表示可以传递E或者E所有的子类类型
- ?super E:表示可以传递E或者E所有的父类类型
如果类型不确定,但是能知道以后只能传递某个继承体系中的,就可以泛型的通配符,关键点:可以限定类型的范围。
泛型的继承问题
- 泛型不具备继承性,但是数据具备继承性
1. 如:
方法 KeepPet3, 形参为 Animal 的集合:
传递一个同是 Animal 类型的集合,传递没问题,
这时若换成传递子类 Cat 的集合,会报错
所以说泛型不具备继承性
2.但是数据具备继承性
综合练习:
Animal:
public abstract class Animal {private String name;private int age;//构造方法+set+get//定义一个抽象方法public abstract void eat();
Cat:
public abstract class Cat extends Animal{// 调用构造方法public Cat(){};public Cat (String name,int age){super(name,age);}
}
Dog:
public abstract class Dog extends Animal{//调用构造方法public Dog(){}public Dog(String name, int age){super (name ,age);}}
哈士奇:
public class Huskies extends Dog {//调用构造public Huskies(){};public Huskies(String name,int age){super(name,age);}@Overridepublic void eat() {System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的哈士奇,正在吃骨头,边吃边拆家");}
}
泰迪:
public class Teddy extends Dog{//调用构造方法public Teddy(){}public Teddy(String name, int age){super (name ,age);}@Overridepublic void eat() {System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的泰迪,正在吃骨头,边吃边蹭");}
}
波斯猫:
public class PersianCat extends Cat{调用构造方法
public PersianCat(){};
public PersianCat(String name,int age){
super(name,age);
}@Overridepublic void eat() {System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的波斯猫,正在吃小饼干");}}
狸花猫:
public class TanukiCat extends Cat{//调用构造public TanukiCat(){};public TanukiCat(String name,int age){super(name,age);}@Overridepublic void eat() {System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的狸花猫,正在吃鱼");}
}
Test:
public class Test {public static void main(String[] args) {//动物ArrayList<Animal> list1 = new ArrayList<>();//猫ArrayList<Cat> list2 = new ArrayList<>();list2.add(new PersianCat("小花", 3));list2.add(new TanukiCat("小喵", 2));//狗ArrayList<Dog> list3 = new ArrayList<>();list3.add(new Teddy("小黑", 2));list3.add(new Huskies("小汪", 3));KeepPet1(list2);//猫KeepPet2(list3);//狗KeepPet3(list1);//动物}//要求1该方法能养所有品种的猫,但是不能养狗public static void KeepPet1(ArrayList<? extends Cat> list) {list.forEach(cat -> cat.eat());}//要求2:该方法能养所有品种的狗,但是不能养猫public static void KeepPet2(ArrayList<? extends Dog> list) {Iterator it=list.listIterator();while(it.hasNext()){Dog dog=(Dog)it.next();dog.eat();}}//要求3:该方法能养所有的动物,但是不能传递其他类型public static void KeepPet3(ArrayList<Animal> list) {for (Animal a : list) {a.eat();}}
}
控制台:
一只叫做小花的,3岁的波斯猫,正在吃小饼干
一只叫做小喵的,2岁的狸花猫,正在吃鱼
一只叫做小黑的,2岁的泰迪,正在吃骨头,边吃边蹭
一只叫做小汪的,3岁的哈士奇,正在吃骨头,边吃边拆家