参考文章:
什么是泛型?为什么要使用泛型?
泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
1. 泛型概述
我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作时,这时必须采用类型转换。
泛型的引出
public class GenericDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc");
coll.add("itcast");
coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
String str = (String) it.next();
System.out.println(str.length());
}
}
}
程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢? 我们来分析下:由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException异常。 那么我们怎么来解决这个问题呢? Collection虽然可以存储各种对象,但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
- 泛型:可以在类或方法中预支地使用未知的类型。
tips:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型,可以存储任意类型的数据,但是会不安全,会发生异常。
2. 使用泛型的好处
说了这么多,你可能会问,泛型到底会给我们编程带来了哪些好处呢?
- 将运行时期(代码编译运行之后抛出的异常)的ClassCastException异常,转移到了编译时期(写代码的时候会报错)。
- 避免了类型强转的麻烦,存储的是什么类型,取出的就是什么类型。
弊端:泛型是什么类型,就只能存储什么类型的数据。
我们通过如下代码体验一下:
public class GenericDemo2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>();
list.add("海贼王");
list.add("黑执事");
// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
tips: 泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
2.1. 泛型的定义与使用
泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中,将数据类型作为参数进行传递。我们平常在集合中会大量使用到泛型,我们知道泛型是一个未知数据类型,当我们不确定使用什么数据类型的时候,可以使用泛型。泛型可以接受任意的数据类型,可以是Integer,String, Student…。但是在创建对象的时候最好确定泛型的类型。
定义和使用含有泛型的类
定义格式:
修饰符 class 类名<代表泛型的变量> { }
tip:
泛型也可以看成是一个变量,用来接收数据类型
E e : Element 元素
T t : Type 类型
例如,API中的ArrayList集合:
class ArrayList<E> {
public boolean add(E e){ }
public E get(int index){ }
....
}
使用泛型: 即什么时候确定泛型。
1. 在创建对象的时候确定泛型
例如,ArrayList<String> list = new ArrayList<String>();
此时,变量E的值就是String类型,那么我们的类型就可以理解为:
class ArrayList<String> {
public boolean add(String e){ }
public String get(int index){ }
...
}
再例如,ArrayList<Integer> list = new ArrayList<Integer>();
此时,变量E的值就是Integer类型,那么我们的类型就可以理解为:
class ArrayList<Integer> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
2. 自定义泛型类
public class MyGenericClass<MVP> {
//没有MVP类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
使用:
public class GenericClassDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass<String> my = new MyGenericClass<String>();
// 调用setMVP
my.setMVP("路飞");
// 调用getMVP
String mvp = my.getMVP();
System.out.println(mvp);
//创建一个泛型为Integer的类
MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
my2.setMVP(123);
Integer mvp2 = my2.getMVP();
}
}
3. 含有泛型的方法
定义含有泛型的方法:泛型定义在方法的修饰符和返回值之间
定义格式:
修饰符 <代表泛型的变量> 返回值类型 方法名(参数(使用泛型)){
方法体;
}
// 含有泛型的方法,在调用方法的时候确定泛型的数据类型
// 传递什么类型的参数,泛型就是什么类型
代码演示:
public class MyGenericMethod {
// 定义泛型的方法
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
// 定义一个含有泛型的静态方法
public static <S> void show3(S s) {
System.out.println(s);
}
}
使用格式:调用方法时,确定泛型的类型
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
// 静态泛型方法调用
MyGenericMethod.show3("abc");
MyGenericMethod.show3(56);
MyGenericMethod.show3(true);
}
}
4. 含有泛型的接口
定义格式:
修饰符 interface 接口名<代表泛型的变量> { }
例如,
public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}
使用格式:
①定义类时确定泛型的类型
实现方法:定义接口的实现类,实现接口,指定接口的泛型
// 拿Scanner类举例,根据源码分析
public interface Iterator<E> {
E next();
}
// 接口实现类
Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默就是String
public final class Scanner implements Implements Iterator<String> {
public String next() {}
}
例如:
// 接口实现类,
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
此时,泛型E的值就是String类型。
②始终不确定泛型的类型,直到创建对象时,确定泛型的类型
使用方法: 接口使用什么泛型,实现类就使用什么泛型,
类跟着接口走,就相当于定义了一个含有泛型的类,
创建对象的时候确定泛型的类型。
接口定义:
public interface List<E> {
boolean add(E e);
E get(int index);
}
接口实现类:
public class ArrayList<E> implements List<E> {
public boolean add(E e) { }
public E get(int index) { }
}
例如:
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
确定泛型:
/*
* 使用
*/
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
2.2. 泛型通配符
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>
表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
① 通配符基本使用
泛型的通配符: 不知道使用什么类型来接收的时候,此时可以使用?
,?表示未知通配符,可以是任意的数据类型。
使用方式:
- 不能创建对象使用
- 只能作为方法的参数使用
此时只能接受数据,不能往该集合中存储数据。
举个栗子:
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//?代表可以接收任意类型
tips:
泛型不存在继承关系
Collection list = new ArrayList();这种是错误的。
② 通配符高级使用----受限泛型
之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限限定:
- 格式:
类型名称 <? extends 类 > 对象名称
- 意义:
只能接收该类型本身及其子类
泛型的下限限定:
- 格式:
类型名称 <? super 类 > 对象名称
- 意义:
只能接收该类型本身及其父类型
比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
/*
类与类之间的继承关系
Integer extends Number extends Object
String extends Object
*/
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}