泛型

泛型

泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换

把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想

使用泛型的主要优点是能够在编译时而不是在运行时检测错误。

但在静态方法 中不能使用类的泛型。

泛型类在使用的时候，如果不指定类型，那么就是object类型的。最好是指定类型。

泛型类的继承。

​ 如果子类在继承带泛型的父类时，指明了泛型类型（也就是说定义的时候就制定了类型）。则实例化子类对象时，不再需要指明泛型。

public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类

​ 子类保留父类的泛型。

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

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

泛型方法：

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
换句话说，泛型方法所属的类是不是泛型类都没有关系。
泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

    public static <E>  List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;
    }

通配符

通配符的使用
   通配符：? 不可以添加数据，除了Null.
   类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

  @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('?');
        list.add(null);
        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println("list.size() = " + list.size());
        System.out.println(o);
    }

有限制条件的通配符的使用。
? extends A 上限最多是A 不可以添加数据，无法确定是什么类型:
G<? extends A> 可以作为G和G的父类，其中B是A的子类

? super A 下限最少是A，可以添加数据，添加A的子类型数据即可:
G<? super A> 可以作为G和G的父类，其中B是A的父类

    @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());

    }