泛型：就是一種不確定的資料型別。
比如：ArrayList<E> E就是泛型。 這種不確定的資料型別需要在使用這個類的時候才能夠確定出來。
泛型可以省略，如果省略，預設泛型是Object型別。


自定義泛型類

 1 package com;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 //自定義泛型類
 7 public class order<T> {
 8     private String orderName;
 9     private int orderId;
10     private
 
 T t;
11     List<T> list = new ArrayList<T>();
12     public void add(){
13         list.add(t);
14     }
15     public T getT(){
16         return t;
17     }
18     public void setT(T t){
19         this.t = t;
20     }
21     public String getOrderName() {
22         return orderName;
 
23     }
24     public void setOrderName(String orderName) {
25         this.orderName = orderName;
26     }
27     public int getOrderId() {
28         return orderId;
29     }
30     public void setOrderId(int orderId) {
31         this.orderId = orderId;
32     }
33     @Override
34     public String toString() {
 
35         return "order [orderId=" + orderId + ", orderName=" + orderName
36                 + ", t=" + t + "]";
37     }
38     
39     
40 }

注意：

1.在靜態方法中不能使用泛型，因為靜態方法早於物件建立執行

2.異常類不能是泛型的

泛型在繼承方面的體現

類A是類B的父類，G<A>和G<B>二者不具備子父類關係，二者是並列關係。

補充：類A是類B的父類，A<G> 是 B<G>的父類

萬用字元？的使用：

 1 import org.w3c.dom.ls.LSInput;
 2 
 3 import java.util.Iterator;
 4 import java.util.List;
 5 
 6 public class test {
 7     public static void main(String[] args) {
 8         List<Object> list1 = null;
 9         List<String> list2 = null;
10 
11         List<?> list = null;
12 
13         list = list1;
14         list = list2;
15 
16         test t = new test();
17         t.show(list1);
18         t.show(list2);
19     }
20 
21     public void show(List<?> list){
22         Iterator<?> iterator = list.iterator();
23         while(iterator.hasNext()) {
24             Object obj = iterator.next();
25             System.out.println(obj);
26         }
27     }
28 
29 }

新增（寫入）：對於List<?>不能向起內部新增資料，null除外

獲取（讀取）：允許讀取資料，讀取的資料型別為object

有限制條件的萬用字元的使用

? extends T ----- 型別上界

這個時候這個萬用字元可以配的範圍就是 T型別物件和T型別子類的物件
形象的也可以看成是 : (-oo , T];
就是負無窮到T — 把T包含在內
那麼這個時候G<? extends A>就可以作為G< A>和G< B>的父類,其中A是B的父類

? super T — 型別下界

這個時候這個萬用字元可以配的範圍就是T型別的物件和T型別的父類的物件
形象的說也可以看成是: [T , +oo)
也就是T到正無窮
那麼這時候G<? super A> 就可以作為G< A>和G < C>的父類,其中A是C的子類

 1  /*
 2     有限制條件的萬用字元的使用
 3     ? extends A:
 4     G<? extends A> 可以作為G<A>和G<B>的父類，其中B是A的子類
 5     ? super A:
 6     G<? super A> 可以作為G<A>和G<B>的父類，其中B是A的父類
 7      */
 8     @Test
 9     public void test4(){
10         List<? extends Person> list1 = null;//<=
11         List<? super Person> list2 = null;//>=
12  
13         List<Student1> list3 = new ArrayList<Student1>();
14         List<Person> list4 = new ArrayList<Person>();
15         List<Object> list5 = new ArrayList<Object>();
16  
17         list1 = list3;
18         list1 = list4;
19 //        list1 = list5;
20  
21 //        list2 = list3;
22         list2 = list4;
23         list2 = list5;
24  
25         //讀取資料：
26         list1 = list4;
27         Person p = list1.get(0);
28         //編譯不通過
29 //        Student1 s = list1.get(0);
30  
31         list2 = list4;
32         Object o = list2.get(0);
33         //編譯不通過
34 //        Person o = list2.get(0);
35  
36         //寫入資料:
37         //編譯不通過
38 //        list1.add(new Student1());
39  
40         //編譯通過
41         list2.add(new Person());
42         list2.add(new Student1());
43  
44     }