为什么用泛型?
早期的Object类型可以接收任意的对象类型,但是在实际的使用中,会有类型转换的问题。也就存在这隐患,所以Java提供了泛型来解决这个安全问题。
什么是泛型?
- 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。
- 参数化类型,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式,然后使用/调用时传入具体的类型。
- Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,泛型的好处就是在编译的时候能够检查类型安全。
泛型类
.泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。
一个简单例子
/**
*/
public class CommonResult <T>{
private Integer code;
private String mes;
private T data;
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMes() {
return mes;
}
public void setMes(String mes) {
this.mes = mes;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
public class CommenTest {
public static void main(String[] args) {
CommonResult<String> commonResult=new CommonResult<>();
commonResult.setData("sssss");
commonResult.setData(1000);
}
}
- 泛型的类型参数只能是类类型
- 泛型的类型参数可以有多个
- 如果没有定义具体类型,默认为Object
泛型接口
- 子类也是泛型类,子类和父类的泛型类型要一致
/**
* 父类/父接口 如果是有泛型的
* 那么子类继承/实现后 有两种选择
* 1.如果子类没有泛型,那么父类/接口必须在编译期间指明泛型的类型
*
* 2.子类和父类/接口 都仍然有泛型的
* @param <T>
*/
public class User<T> implements Comparable<T> {
@Override
public int compareTo(T o) {
return 0;
}
public static void main(String[] args) {
new User<String>();
}
}
- 子类不是泛型类,父类要明确泛型的数据类型
public class User implements Comparable<User>{
@Override
public int compareTo(User o) {
return 0;
}
public static void main(String[] args) {
new User();
}
}
从泛型类派生子类
public class Demo1<T> {
}
- 子类也是泛型类,子类和父类的泛型类型要一致
public class Test1<T> extends Demo1<T>{
//子类也是泛型类,子类和父类的泛型类型要一致
public static void main(String[] args) {
new Test1<User>();
}
}
子类不是泛型类,父类要明确泛型的数据类型
public class Test1 extends Demo1<String> {
//子类不是泛型类,父类要明确泛型的数据类型
public static void main(String[] args) {
new Test1();
}
}
泛型通配符
类型通配符一般是使用"?"代替具体的类型实参。
public class Demo2<T> {
public Demo2(T i) {
}
/*?表示实际传入的参数类型可以是任意的*/
public static void show(Demo2<?> obj){
}
Demo2<Integer> integerDemo2=new Demo2<Integer>(123);
Demo2<Number> numberDemo2=new Demo2<>(466);
}
- 泛型通配符上限
类/接口<?extends 实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的子类类型。
public class Demo3<T> {
//<? extends T>泛型类型的上限 只能传入类型以及类型的子类
public void test(Demo3<? extends Number> bd){
}
public static void main(String[] args) {
Demo3<Integer> di=new Demo3<>();
Demo3<Number> dj=new Demo3<>();
Demo3<Object> dk=new Demo3<>();
di.test(di);
dj.test(dj);
dk.test(dk);
}
}
- 类型通配符下限
类/接口<?super 实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的父类类型
public class Demo3<T> {
//<? super Number>类型的下限,只能传入类型以及类型的父类
public void test(Demo3<? super Number> bd){
}
public static void main(String[] args) {
Demo3<Integer> di=new Demo3<>();
Demo3<Number> dj=new Demo3<>();
Demo3<Object> dk=new Demo3<>();
di.test(di);
dj.test(dj);
dk.test(dk);
}
}
类型擦除
泛型是Java 1.5版本才引进的概念,在这之前是没有泛型的,但是,泛型代码能够很好地和之前版本的代码兼容。那是因为,泛到信息只存在于代码编译阶段,在进入JVM之前,与泛型相关的信息会被擦除掉,我们称之为一类型擦除。
泛型类被类型擦除后,相应的类型就被替换成Object类型或者上限类型。
/**
* 泛型类型擦除
*/
public class Demo4 {
@Test
public void listMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//创建一个list集合 指定泛型类型string
List<String> list=new ArrayList<String>();
//添加数据
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
//泛型擦除 往list集合中添加一个integer类型的数据
//1.获取该集合的class对象
Class myclass = list.getClass();
//2.根据方法名获取指定的方法
Method methods = myclass.getMethod("add", Object.class);
//3.运行该方法
methods.invoke(list,21);
//遍历集合,打印输出
System.out.println(list);
}
}
public class Demo5<T> {
/*Demo5是一个泛型类,我们查看它在运行时的状态信息可以通过反射*/
public static void main(String[] args) throws NoSuchFieldException {
ArrayList<String> list=new ArrayList();
Class demo5Class = list.getClass();
Field elementData = demo5Class.getDeclaredField("elementData");
System.out.println(elementData.getName()+":::"+elementData.getType());
}
}