JAVA泛型之<? extends T>:(通配符上限)和<? super T>(通配符下限)

　　一.通配符上限和通配符下限接受的類型

　　通配符上限：<? extends T>

　　通配符下限：<? super T>

　　以下代碼是測試結果，註釋為解釋說明

 1 package xayd.hjj;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 class A{}
 7 class B extends A implements F{}
 8 class C extends A{}
 9 class D extends A{}
10 class E{}
11 interface F{}
12 
13 public class Test{
14     
15     public static void main(String[] args) {        
16         
17         //下麵五行代碼說明:List<? extends A>接受A或者繼承A的類
18         List<? extends A> listA = new ArrayList<A>();
19         List<? extends A> listB = new ArrayList<B>();
20         List<? extends A> listC = new ArrayList<C>();
21         List<? extends A> listD = new ArrayList<D>();
22         // List<? extends A> listE = new ArrayList<E>();  //編譯不能通過,類E與類A無關
23         
24         
25         //下麵三行代碼說明:List<? super B>接受B或者的父類
26         List<? super B> listA1 = new ArrayList<A>();
　　　　　　 List<? super B> listA2 = new ArrayList<B>();
27         List<? super B> listF = new ArrayList<F>();
28         //List<? super B> listC1 = new ArrayList<C>();  //編譯不能通過，類C不是類B的父類
29           
30     }
31 }

　　　二.通配符下限和通配符上限存取問題

　　　通配符上限：<? extends A>

　　　List<? extends A> list = new ArrayList<B>();

　　　這樣定義一個list的時候，是不允許向這個list添加任何東西的。list可以接受其B類型和B的子類。像list中添加對象的時候因為編譯器不能確定這個子類的確切類型，因此不允許向里添加任何對象。唯一可以添加的是null。也可以這樣理解:Fruit是Apple的父類，也是orange的父類。但是你不能說Fruit就是Apple或者orange。

　　　代碼測試如下：

 1 package xayd.hjj;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 class A{}
 6 class B extends A implements F{}
 7 class C extends A{}
 8 class D extends A{}
 9 class E{}
10 interface F{}
11 public class Test{
12     public void a(List<? extends A> list){
13         list.add(null);        //編譯通過，但無實際意義
14         // list.add(new B());  //編譯不能通過
15         // list.add(new A());  //編譯不能通過
16         
17     }
18 
19     public static void main(String[] args) {        
20         Test test = new Test();
21         List<? extends A> listB = new ArrayList<B>();
22         test.a(listB);
23         
24     }
25 }

　　通配符下限：<? super B>

　　List<? super B> list = new ArrayList<A>();

　　這樣定義一個list的時候，允許向這個list添加對象。list可以接受其B類型和B的父類。像list中添加對象的時候編譯器能確定確切類型。也可以這樣理解:Fruit是Apple的父類，也是orange的父類。我們可以說Apple就是一個Fruit。

　　　代碼測試如下：

 1 package xayd.hjj;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 class A{}
 6 class B extends A implements F{}
 7 class C extends A{}
 8 class D extends A{}
 9 class E{}
10 interface F{}
11 public class Test{
12     
13     public void b(List<? super B> list){
14         
15         
16         list.add(new B());     ////編譯通過
17         //list.add(new A());   //編譯不能通過,要使用類型轉換
18         list.add((B) new A()); ////編譯通過      
19         
20     }  
21     public static void main(String[] args) {                
22         List<? super B> listA = new ArrayList<A>();
23         test.b(listA);
24         
25         
26     
27         
28     }
29 }