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());  編譯不通過
    }