【JAVASE（9）】JAVASE学习--泛型篇

泛型
    一、泛型的使用
        1.JDK5.0新增的特性：
            A.泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。
            B.泛型也可以看成是一个变量，用来接收任意数据类型(如Integer，String，Student....)：
                E:e【Element元素】；
                T：t【Type类型】
            C.创建对象的时候确定泛型的类型
            实例一

{
        ArrayList集合在定义的时候，
        不知道集合中会存储什么类型数据，
        所以使用泛型。E：未知数据类型
    public class ArrayList<E>{
        public boolean add<E e>{}
        public E get(int index){}
    }

        创建集合对象的时候，就会确定泛型的数据类型
    ArrayList<String> list=new ArrayList<>();------->其中String把泛型E覆盖
}

        2.在集合中使用泛型：
            创建集合对象不使用泛型。
                好处【集合不使用泛型，默认类型就是Object类型，可以存储任意类型数据】
                弊端【不安全，会引发异常】
            创建集合对象使用泛型。
                好处【
                    1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
                    2.把运行异常（代码运行后会抛出的异常），提升到了编译期间（写代码时会报错）
                】；
                弊端【泛型是什么类型，只能存储什么类型的数据】

            小节：
                1.集合接口或者集合类在jdk5.0时都修改为带泛型的结构。
                2.在实例化集合时。可以指明具体的泛型类型
                3.指明完以后，在集合类或者接口中凡是定义类或者接口时，内部结构(如：方法、构造器、属性等)使用到类的泛型的位置，
                都指定为实例化的泛型的类型

如：add(E e) ---->实例化以后：add(Integer e)

                4.注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
                5.若实例化时，没有指明泛型类型，默认类型为java.long.Object类型
                6.Jdk7之前：

HashMap<指明泛型类型> map = new HashMap<指明泛型类型>();

                 JDK7新特性：类型推断，用于简化操作：

HashMap<指明泛型类型> map = new HashMap<>();

                7.要求：若定义了带泛型的类，则在实例化此类时就要指明此类的泛型
                8.在泛型中不能出现基本类，所有基本类均用包装类替代

        3.自定义泛型结构：泛型类、泛型接口；泛型方法

    二、自定义泛型结构
        1、自定体泛型类：public class 带泛型的类名称<T>{T 属性名称；其他代码}；在实例化时指明此泛型类的泛型型具体是什么类型

        2、子类继承带泛型父类的格式：
            带泛型的父类：

public class 带泛型的父类名称<T1,T2>{}

            普通子类格式：
                子类继承

public class 子类名称 extends 带泛型的父类名称{}
public class 子类名称 extends 带泛型的父类名称<指明所有泛型类型>{}

            带泛型子类格式：
                子类继承

public class 子类名称<T1,T2> extends 带泛型的父类名称<T1,T2>{}
public class 子类名称<T2> extends 带泛型的父类名称<Integer,T2>{}

                子类拥有自己的泛型

public class 子类名称<E1,E2> extends 带泛型的父类名称{}
public class 子类名称<E1,E2> extends 带泛型的父类名称<指明所有泛型类型>{}
public class 子类名称<E1,E2,T1,T2> extends 带泛型的父类名称<T1,T2>{}
public class 子类名称<E1,E2,T2> extends 带泛型的父类名称<Integer,T2>{}

        在利用子类去继承带有泛型的父类时，要么子类指明继承的父类的泛型是什么类型，要么在子类实例化时指明此泛型类的泛型型具体是什么类型

        3、自定义泛型结构时需要注意：
            1.泛型类存在多个泛型参数，那么声明时应该声明为：<E1,E2,E3,...>
            2.泛型类个构造器通不带泛型类的构造器声明时是一样的，均是:public 类型名称(){}；但在实例化时要补上<>同时指明泛型类型
            3.实例化以后，指明泛型是什么类型就用什么类型
            4.泛型不同的引用（变量）不能相互赋值。
                >尽管在编译时ArrayList(String)和ArrayList(Integer)是两种类型，但在运行时只有一个ArrayList被加载到JVM中
            5.泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但并不等价于Object。泛型要使用一路都用。要不要，一路都不要用
            6.一个接口或抽象类带有泛型结构，则此接口或抽象类并不能因为带有泛型而直接创建实例对象
            7.在静态方法中不能使用类的泛型:原因是{类的泛型是在造对象的时候指定的，而静态结构要早于对象的创建}
            8.异常类不能是泛型的，使用try..catch...结构也不能使用泛型（编译不通过）
            9.不能使用new E[]创建泛型数组，编译不通过。但是可以用：E[] elements=(E())new Object[capacity];声明泛型数组，其实质是
                new了一个Object类型数组，当次数组创建完成后在将其强制类型转换为了泛型数组，这样才能保证此数组中存放的是泛型类及泛型类的
                子类对象
                如：ArrsayList源码中声明：Object[] elementData,二非泛型参数类型数组：
                    子类不保留父类的泛型：按需实现
                        >没有类型 擦除
                        >具体类型
                     子类保留父类的泛型：泛型子类
                        >全部保留
                        >部分保留
                 即子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
        tip：DAO:data(base) access object(数据访问对象）：即对数据库通用操作(增删改查)的工具类

    三、泛型方法：

        在方法中出现了泛型的结构，泛型参数与类的泛型参数没关系，即泛型方法所属类是不是泛型类无所谓
        泛型方法在调用时，指明泛型参数的类型；泛型方法可以是静态的，因为泛型参数是在调用方法时确定的，并非在实例化类时确定
        定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间
        格式：

修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{方法体}


public <E> E 方法名称(){
    //一顿操作;
    return E;
}


public <E> 集合<E> 方法名称(E[] 形参名称){
    //一顿操作;
    return 集合;
}


public static <E> 集合<E> 方法名称(E[] 形参名称){
    //一顿操作;
    return 集合;
}

        含有泛型的方法，在调用方法的时候确定泛型的数据类型，传递什么类型的参数，泛型就是什么类型

    四、分析在继承方面的体现：
        定义一个方法能遍历ArrayList集合：这时候我们不知道ArrayList集合使用什么类型数据可用泛型通配符？来接收数据
        泛型没有继承概念：
            类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系;然而可以存在A<G>和B<G>这就存在继承关系(此时不仅仅针对子父类还可以是接口)
        实例分析

{
    List<Object> list1=new ArrayList<>();
    List<String> list2=new ArrayList<>();

    list1=list2;
        此时list1和list2的类型不具有子父类关系，编译不通过


反正法：
    若list1=list2;成立，那么list1从原来的指向堆空间中的List<Object>，
    改为和list2一样指向堆空间的List<String>，若通过list1.add()方法，
    将Integer类型数据存入List<String>，这显然不合法。
}

    五、含有泛型的接口：
        含有泛型的接口第一种使用方式：
            定义接口的实现类，实现接口，指定接口的泛型
            public interface Iterator<E>{E next();}

            Scanner类实现了Iterator接口，并且指定接口的泛型String，所以重写next方法默认就是String

public final class Scanner implements Iterator<String>{ 
    public String next(){}
}

        含有泛型的接口第二种使用方法：
            接口使用什么泛型，类跟着接口走。就相当于定义了一个含有泛型的类，创建对象的时候确定泛型类型

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){}
}

    六、通配符的使用:
        1、通配符 ? 【代表任意的数据类型】
        2、使用方法：不能创建对象使用，只能作为方法的参数使用
        类A是类B的父类，G<A>和G<B>二者没有关系，二者的共同父类是G<?>
            对于G<?>：
                添加(写入)：对于G<?>就不能向其内部添加数据,除了添加null之外
                获取(读取):允许读取数据，读取的数据类型为Object
        实例一

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

        List<?> list=null;
            采用通配符

        list=list1;
            成功赋值

        list=list2;
            成功赋值

        print(list1);
            成功调用

        print(list2);
            成功调用
    }


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

        2、有限制条件的通配符：
            泛型的上限限定：? extends 父类：即父类及其以下
                G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类{ -无穷~类A }
                表示使用的泛型只能是A类型的子类/本身
            泛型的下限限定：? super 父类：即父类及其以上
                G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类{ 类A~正无穷 }
                表示使用的泛型只能是A类型的父类/本身
            实例一

{
注：其中student类继承于person类，且这两个类均不带泛型结构

    @Test
    public void test(){
        List<? extends Person> list1=null;
        List<? super Person> list2=null;

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

        list1=list3;
        list1=list4;

        //不含比父类大的
        // list1=list5; //编译不通过

        //不含比父类小的
        // list2=list3; //编译不通过

        list2=list4;
        list2=list5;

        //读数据
        list1=list4;
        Person p = list1.get(0);

        list2=list4;
        Object obj = list2.get(0);

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

        //编译运行都过
        list2.add(new Person());
        list2.add(new Student());
    }
}