1. import java.util.ArrayList;
   
2. import java.util.Collection;
   
3. 
   
4. 
   
5. //泛型通配符使用
   
6. public class GenericTest1
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 Collection<Integer> collection=new ArrayList<Integer>();
    
11.                 collection.add(1);
    
12.                 collection.add(10);
    
13.                
    
14.                 print(collection);
    
15.                
    
16.                
    
17.                
    
18.         }
    
19.         //我这里用泛型类型   和 用通配符 有啥区别         搞蒙了..
    
20.   //public static <E> void print(Collection<E> collection)
    
21.         public static  void print(Collection<?> collection)
    
22.         {
    
23.                 for (Object object: collection)
    
24.                 {
    
25.                        
    
26.                         //不能调用与使用参数类型有关的方法
    
27.                         //System.out.println(collection.add(1));
    
28.                         System.out.println(object);
    
29.                 }
    
30.                
    
31.                 System.out.println(collection.size());
    
32.                
    
33.         }
    
34. }

复制代码

有区别的：
Collection<E> 表示  集合里 是  E类的实例
Collection<?>表示 集合里的对象类型不确定，未指定
如果你用Collection<E> ，而System.out.println(collection.add(1));之所以报错是因为，1他不是E类型的参数
如果你用Collection<?>，System.out.println(collection.add(1));也会报错，因为他不知道自己未来匹配的就一定是Integer。当使用Collection<?>的时候只有调用不涉及类型参数的方法才不会报错，比如collection.size()。
帮你改了一下程序：

1. package learn;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. import java.util.Collection;
   
6. 
   
7. 
   
8. 
   
9. 
   
10. 
    
11. //泛型通配符使用
    
12. 
    
13. public class GenericTest1
    
14. 
    
15. {
    
16. 
    
17.         public static void main(String[] args)
    
18. 
    
19.         {
    
20. 
    
21.                 Collection<Integer> collection=new ArrayList<Integer>();
    
22. 
    
23.                 collection.add(1);
    
24. 
    
25.                 collection.add(10);
    
26. 
    
27.                
    
28. 
    
29.                 print(collection);
    
30. 
    
31.                
    
32. 
    
33.                
    
34. 
    
35.                
    
36. 
    
37.         }
    
38. 
    
39.         //我这里用泛型类型   和 用通配符 有啥区别         搞蒙了..
    
40. 
    
41. public static  void print(Collection<Integer> collection)     //这里泛型用Integer
    
42. 
    
43.         //public static void print(Collection<?> collection)
    
44. 
    
45.         {
    
46. 
    
47.                 for (Object object: collection)
    
48. 
    
49.                 {
    
50. 
    
51.                         
    
52. 
    
53.                         //不能调用与使用参数类型有关的方法
    
54. 
    
55.                       System.out.println(collection.add(1));     
    
56. 
    
57.                         System.out.println(object);
    
58. 
    
59.                 }
    
60. 
    
61.                
    
62. 
    
63.                 System.out.println(collection.size());
    
64. 
    
65.                
    
66. 
    
67.         }
    
68. 
    
69. }

复制代码

ArrayList<String> al = new ArrayList<String>();

  al.add("abc1");
  al.add("abc2");
  al.add("abc3");

  ArrayList<Integer> al1 = new ArrayList<Integer>();
  al1.add(4);
  al1.add(7);
  al1.add(1);

  printColl(al);
  printColl(al1);

public static void printColl(ArrayList<？> al)//这样是可以的。用类型占位符，表示类型不明确。
{
  Iterator<？> it = al.iterator();


  while(it.hasNext())
  {
   System.out.println(it.next().length());//这个是不可以的，因为不能使用类型的特有方法，但是toString()是可以的，因为都有啊。
  }
}




ArrayList<String> al = new ArrayList<String>();
  al.add("abc1");
  al.add("abc2");
  al.add("abc3");
  ArrayList<Integer> al1 = new ArrayList<Integer>();
  al1.add(4);
  al1.add(7);
  al1.add(1);
  printColl(al);
  printColl(al1);

public static <T> void printColl(ArrayList<T> al)//这样也是可以的。T与？的区别就是T是具体类型，可以接收并操作这个类型。
{
  Iterator<T> it = al.iterator();
  while(it.hasNext())
  {
    T t = it.next();
    System.out.println(t);
  }
}

秦久启 发表于 2014-4-24 12:24
ArrayList al = new ArrayList();

  al.add("abc1");

谢了                           

public static <E> void print(Collection<Integer> collection)  //明确定的集合的元素类型为Integer
所以 System.out.println(collection.add(1)); 没问题 （1自动装箱后就是Integer）

改为public static <E> void print(Collection<Object> collection) //明确定的集合的元素类型为Object
因为父类的引用可以接收子类的对象，所以System.out.println(collection.add(1)); 没问题，实际上collection.add(任何类类型对象)都可以。

改为public static <E> void print(Collection<？ extends Object> collection) 可以吗，当然不可以，为什么呢
原型：<？ extends T>这个? extends T通配符告诉编译器我们在处理一个类型T的子类型，但我们不知道这个子类型究竟是什么。因为没法确定，为了保证类型安全，我们就不允许往里面加入任何这种类型的数据。另一方面，因为我们知道，不论它是什么类型，它总是类型T的子类型(用父类引用来接收子类对象没问题)，当我们在读取数据时get()，能确保得到的数据是一个T类型的实例：

重点两句话：
1.用父类引用来接收子类对象没问题
2.不确定不安全所以不可以