Java泛型

java泛型

为什么要有泛型

泛型：可以大概理解为标签
泛型的设计背景：
    集合容器类在设计、声明之出不能确定集合中存放的数据类型。所以在JDK1.5之前，集合被设计存储的
    数据类型为object,在jdk1.5之后。提出了泛型。因为这个时候除了元素的类型不确定，其他的部分
    是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数
    这个类型参数叫做泛型。Collection< E >，List< E >，ArrayList< E > 这个< E >就是类
    型参数，即泛型。jdk1.5之后重写了集合框架，采用了泛型机制。
泛型的概念：
    所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值
    及参数类型。这个类型参数将在使用时(例如， 继承或实现这个接口，用这个类型声明变量、创建对
    象时)确定(即传入实际的类型参数，也称为类型实参)。
    参数化类型(Parameterized type)：jdk1.5引入，允许我们在创建集合时同指定集合元素的类
    型.正如：List< String >，这表明该List只能保存字符串类型的对象。
    泛型也就是代表类型的参数，在声明时进行动态的指定。实际上在便衣时期就确定好了
 泛型好处：
   解决元素存储的安全问题：集合存储元素是类型是确定好的，不能任意类型都放入集合中。也降低了
   后续对集合元素在进行操作时出现问题的可能。
   解决获取元素时期，需要强制类型装换的问题。

集合中使用泛型

在实例化集合类中，指定集合元素的具体类型
在指定类型后，在集合类或接口中凡是定义类或接口时，内部结构(方法、属性、构造器等)使用到类的泛
型的位置，都指定为实例化的泛型类型。
如果实例化时期没有指定具体类型默认为object类型
说明(泛型使用的是包装类型，不能使用基本数据类型)

自定义泛型类/方法

注意：interface List< T > 和 class GenTest < K,V > 其中，T,K,V不代表值，而是表示类
型。这里使用任意字母都可以。 常用T表示，是Type的缩写。
一定要在类名后面指定类型参数的值(类型)--》泛型的使用
T只能是类，不能用基本数据类型填充。但可以使用包装类填充--》泛型不能指定为基本数据类型
泛型不同的引用不能相互赋值。--》具体泛型类型不同的实体对象之间。
/**
 ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        //泛型不同的引用不能相互赋值
//        list1 = list2;//编译不通过
*/
如果泛型结构是一个抽象类或着接口，那么这个泛型类不能被实例化
静态方法中不能使用类的泛型。以为静态方法的加载早于类的实例对象确定具体泛型
异常类不能指定泛型
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
    子类不保留父类的泛型：按需实现
        没有类型 擦除
        具体类型
    子类保留父类的泛型：泛型子类
        全部保留
        部分保留

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

方法的泛型化

方法，也可以被泛型化，不管此时类的定义是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数
类型就是传入数据的类型
[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
泛型方法可以为静态方法，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。原因是泛型方
法的泛型类型不依靠于泛型类你的泛型。

@Test
    public void test2(){//测试泛型方法
        List<Integer> list = copyFromArrayListToList(new Integer[]{1, 2, 3, 4});
        System.out.println(list);
    }

    //将ArrayList数组中的内容复制到list数组中
    public <E> List<E> copyFromArrayListToList(E [] arr){
        ArrayList<E> list = new ArrayList<E>();
        for (E e : list){
            list.add(e);
        }
        return list;
    }

泛型在继承上的体现

注意：如果B是A的一个子类型(子类或者子接口)，而G是具有泛型声明的类或接口，G< B >并不是G< A 
>的子类型，两者为并列关系，String是Object的子类，但是List< String >并不是List< Object 
> 的子类,这两个类是并列的类。

public void testGenericAndSubClass() {
Person[] persons = null;
Man[] mans = null;
// 而 Person[] 是 Man[] 的父类.
persons = mans;
Person p = mans[0];
// 在泛型的集合上
List<Person> personList = null;
List<Man> manList = null;
// personList = manList;(报错)
}

    @Test
    public void test3(){
        ArrayList<String> arrayList = new ArrayList<>();
        List<String> list = null;
        //这样复制时可以的
        list = arrayList;
        //等价于List<String> list1 = new ArrayList<>();
    }

通配符的使用

通配符：？
类A是类B的父类，G< A >和G< B >是没有关系的并列的，二者共同的父类是：G<?>
读取List的对象list中的元素时，永远是安全的，因为不管list的真实类型 是什么，它包含的都是
Object。object是所有类型的父类。
写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中 添加对象。唯一的例外是
null，它是所有类型的成员。null可以被赋值任何包装类型，null是任何类型的子类。

@Test
    public void test3(){
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;
        //编译通过
//        print(list1);
//        print(list2);

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        
        list = list3;
        //添加(写入)：对于List<?>就不能向其内部添加数据。
        //除了添加null之外。
//          list.add("DD");//编译不通过
        list.add(null);

        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);//读取AA
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

有限制条件的通配符

通配符指定上限
上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
通配符指定下限
下限super：使用时指定的类型不能小于操作的类，即>=
举例
< ? extends Number > :(无穷小 , Number] 只允许泛型为Number及Number子类的引用调用
< ? super Number >[Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
< ? extends Comparable >只允许泛型为实现Comparable接口的实现类的引用调用

@Test
    public void test4(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过
        //Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());

        //编译通过
        list2.add(new Person());
        list2.add(new Student());
    }