java泛型

为什么用泛型?

早期的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);

    }
}

1. 泛型的类型参数只能是类类型
2. 泛型的类型参数可以有多个
3. 如果没有定义具体类型,默认为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());

    }
    
}