Java泛型

一、泛型

泛型是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许程序员在编译时监测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

二、泛型结构

泛型类、泛型接口、泛型方法

public class Order<T> {
//    类的内部结构可以使用类的泛型
    private String orderName;
    private T orderT;

    public Order(){
//        T[] arr = new T[10]; 编译不通过
        T[] arr = (T[]) new Objects[10];
    }

    public Order(String orderName, T orderT){
        this.orderName = orderName;
        this.orderT = orderT;
    }

    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

//    静态方法中不能使用类的泛型
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

//    泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
//    换句话说，泛型方法所属的类是不是泛型类都没有关系
//    泛型方法
    public <E> List<E> copyFromArrayToList(E[] arr){
        List<E> list = new ArrayList<>();
        for (E e : arr){
            list.add(e);
        }
        return list;
    }

}

如果定义了泛型类，需实例化没有指明类的泛型，则认为此泛型类型为Object类型；

建议，实例化时指明类的泛型

    public void test2(){
        Order orderA = new Order();
        orderA.setOrderT("a");
        orderA.setOrderT(123);

        Order<String> orderB = new Order<>();
        orderB.setOrderT("a");
        orderB.setOrderT("b");
    }

三、泛型在继承方面的体现

有Person类、Student类、Order类、SubOrder类

class Person {

}

class Student extends Person {

}


class Order<T> {

}

class SubOrder<T> extends Order<T> {

}

类A是类B的父类，G<A>和G<B>二者不具备子父类关系

类A是类B的父类，A<G>是B<G>的父类

    public void test3(){
        List<Person> peoples = null;
        List<Student> students = null;
//        peoples = students;   编译不通过
        Order<Object> order = null;
        SubOrder<Object> subOrder = null;
        order = subOrder;
    }

四、通配符的使用

通配符：?

    public void test4(){
        List<?> list = null;
        List<Object> list1 = null;
        List<String> list2 = null;
        list = list1;
        list = list2;
//        添加，对于List<?>就不能向其内部添加数据，除了添加null
//        list.add("b");   编译不通过
//        list.add(null);
        print(list);
        print(list1);
        print(list2);
    }

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

五、有限制条件通配符的使用

G<? extends A>可以作为G<A>和G<B>的父类的，其中B是A的子类

G<? super A>可以作为G<A>和G<B>的父类的，其中B是A的父类

    public void test5(){
//        可以作为Person及其子类的父类
        List<? extends Person> list1 = null;
//        可以作为Person及其父类的父类
        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 = list3;
        Person person = list1.get(0);
//        Student student = list1.get(0);   编译不通过
        
        list2 = list4;
        Object object = list2.get(0);
//        Person p = list2.get(0);  编译不通过
        
//        list1.add(new Student()); 编译不通过，因为可能出现父类转子类
//        list2.add(new Object());  编译不通过
    }