1. public class GenericDemo4泛型上限 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 ArrayList<Person> al=new ArrayList<Person>();//为什么就可以直接接受子类，
   
5.                 al.add(new Student());
   
6.                 al.add(new Person());
   
7.                 HashSet<Worker> hs=new HashSet<Worker>();
   
8.                 hs.add(new Worker());
   
9.                
   
10.                 Iteratorprint(al);
    
11.                 Iteratorprint(hs);
    
12.         }
    
13.         //泛型的上限
    
14.         private static void Iteratorprint(Collection<? extends Person> al) {//为什么不能直接接受子类
    
15.                 Iterator<? extends Person> it=al.iterator();
    
16.                 while(it.hasNext()){
    
17.                         System.out.println(it.next());
    
18.                 }
    
19.         }
    
20. 
    
21. }
    

复制代码

这个程序没有错误页没有警告，我就是想问问那两个问题，

1. package aa;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Collection;
   
5. import java.util.HashSet;
   
6. import java.util.Iterator;
   
7. 
   
8. public class GenericDemo4 {
   
9. 
   
10.         public static void main(String[] args) {
    
11. 
    
12.                 ArrayList<Person> al = new ArrayList<Person>();// 为什么就可以直接接受子类，
    
13. 
    
14.                 al.add(new Student());
    
15. 
    
16.                 al.add(new Person());
    
17. 
    
18.                 HashSet<Worker> hs = new HashSet<Worker>();
    
19. 
    
20.                 hs.add(new Worker());
    
21. 
    
22.                 Iteratorprint1(al);
    
23. 
    
24.                 Iteratorprint(hs);
    
25. 
    
26.         }
    
27. 
    
28.         // 泛型的上限
    
29. 
    
30.         private static void Iteratorprint(Collection<? extends Person> al) {// 为什么不能直接接受子类
    
31. 
    
32.                 Iterator<? extends Person> it = al.iterator();
    
33. 
    
34.                 while (it.hasNext()) {
    
35. 
    
36.                         System.out.println(it.next());
    
37. 
    
38.                 }
    
39. 
    
40.         }
    
41.         private static void Iteratorprint1(ArrayList<Person> al) {// 缩小了集合的范围
    
42. 
    
43.                 Iterator<? extends Person> it = al.iterator();
    
44. 
    
45.                 while (it.hasNext()) {
    
46. 
    
47.                         System.out.println(it.next());
    
48. 
    
49.                 }
    
50. 
    
51.         }
    
52.        
    
53. }
    
54. class Person{
    
55.        
    
56. }
    
57. class Worker extends Person{
    
58.        
    
59. }
    
60. class Student extends Person{
    
61.        
    
62. }

复制代码

第一个问题：子类是特殊的父类，也就是说Student类型也是Person类型；第二个问题：不清楚你说的“为什么不能直接接受子类”，这个子类是什么样的子类？可以举个例子吗？

java_dream 发表于 2014-9-7 14:13
第一个问题：子类是特殊的父类，也就是说Student类型也是Person类型；第二个问题：不清楚你说的“为什么不 ...

第十七行， private static void Iteratorprint(Collection<? extends Person> al)，<? extends Person>改成Person后就不能接受Student了，为什么？

她只是过客 发表于 2014-9-9 20:50
第十七行， private static void Iteratorprint(Collection

虽然Person与Student是是父子关系，数组里可以

1. Student[] s = new Student[2];
   
2. Person[] p = s;

复制代码

但是在泛型里Collection<Person>不是Collection<Student>的父类，所以Collection<Person>参数不能接受Collection<Student>类型的实参。

第一个问题：因为在ArrayList的源码中，addAll方法，有一个泛型上限限定，可以接收在定义时的类及其子类。
第二个问题：可能是泛型限定的问题，除了自己的类型之外，别的不接受，这个我不太清楚。当作个规定就好了

比较器里面 如果能比较父类的对象 就肯定能比较子类的对象了 所以  (Collection<? extends Person> al  就是说参数传的是person和person的父类对象