ArrayList<Integer> list = new ArrayList<Integer>(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。  各位大神们 这个能存吗

应该不能

可以存，泛型的存在时间是在编译时期，而反射的动作是在运行时期。所以可以通过反射添加不同于泛型的类型。
代码如下：

1. package exercise;
   
2. 
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.lang.reflect.Method;
   
5. import java.util.ArrayList;
   
6. import java.util.Iterator;
   
7. 
   
8. /**
   
9. * ArrayList<Integer> list = new ArrayList<Integer>();
   
10. * 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
    
11. * @author feaoes
    
12. *
    
13. */
    
14. public class Test3 {
    
15. 
    
16.         public static void main(String[] args) {
    
17.                 ArrayList<Integer> list = new ArrayList<Integer>();
    
18.                 list.add(1);
    
19.                 list.add(2);
    
20.                 for(Integer it:list)
    
21.                 {
    
22.                         System.out.println(it);
    
23.                 }
    
24.                
    
25.                
    
26.                         try {
    
27.                                 Method clazzMethod=ArrayList.class.getMethod("add", Object.class);
    
28.                                 clazzMethod.invoke(list, "abc");
    
29.                                 Iterator<Integer> it=list.iterator();
    
30.                                 while(it.hasNext())
    
31.                                 {       
    
32.                                         System.out.println(it.next());
    
33.                                 }
    
34.                         } catch (NoSuchMethodException e) {
    
35.                                 e.printStackTrace();
    
36.                         } catch (SecurityException e) {
    
37.                                 e.printStackTrace();
    
38.                         } catch (IllegalAccessException e) {
    
39.                                 e.printStackTrace();
    
40.                         } catch (IllegalArgumentException e) {
    
41.                                 e.printStackTrace();
    
42.                         } catch (InvocationTargetException e) {
    
43.                                 e.printStackTrace();
    
44.                         }
    
45.                        
    
46.                        
    
47.                
    
48.                
    
49.         }
    
50. 
    
51. }
    

复制代码

泛型的出现就是为了限制集合中存放的元素的

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. public class SunJingQi {
   
5. 
   
6.         public static void main(String[] args) {
   
7. 
   
8.                 ArrayList al = new ArrayList();
   
9. 
   
10.                 al.add("孙旌棋");
    
11.                 al.add("孙旌棋");
    
12.                 al.add("孙旌棋");
    
13.                 al.add(123);
    
14.                
    
15.                 for (Iterator it = al.iterator(); it.hasNext();) {
    
16.                         sop(it.next());
    
17.                 }
    
18.         }
    
19. 
    
20.         public static void sop(Object obj) {
    
21.                 System.out.println(obj);
    
22.         }
    
23. 
    
24. }

复制代码

早期这样的代码是没有问题的, 但是带来了安全隐患, 就好像你开发一个银行的项目, 里面有一个集合存放的是金额,结果存进去的字符串, 结果编译竟然还通过了, 想想也是有点危险啊, 所以出现了泛型, 用来限定集合中出现的元素类型, 可以让程序员在编译的时候就能发现问题的所在,

如果加上了泛型,那么会直接报错的额哦

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. public class SunJingQi {
   
5. 
   
6.         public static void main(String[] args) {
   
7. 
   
8.                 ArrayList<String> al = new ArrayList<String>();
   
9. 
   
10.                 al.add("孙旌棋01");
    
11.                 al.add("孙旌棋02");
    
12.                 al.add("孙旌棋03");
    
13.                 al.add(123);// 这里直接就会报错的
    
14.                
    
15.                 for (Iterator<String> it = al.iterator(); it.hasNext();) {
    
16.                         sop(it.next());
    
17.                 }
    
18.         }
    
19. 
    
20.         public static void sop(Object obj) {
    
21.                 System.out.println(obj);
    
22.         }
    
23. 
    
24. }

复制代码

同学,这下你应该明白泛型是用来干嘛的吧

清风有意 发表于 2014-4-20 12:39
可以存，泛型的存在时间是在编译时期，而反射的动作是在运行时期。所以可以通过反射添加不同于泛型的类型。 ...

对反射不是很了解,反射也太强大了...那定义的泛型就没有什么用了

悠然丶 发表于 2014-4-20 12:53
对反射不是很了解,反射也太强大了...那定义的泛型就没有什么用了

定义泛型是为了在编译阶段给程序员看的！避免存入不想要的对象。如果没有定义泛型，那么在运行阶段就会报错，从而降低了客户的体验，这是我们不想要的。

可以存

1. public class Test4 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 ArrayList<Integer> list = new ArrayList<Integer>();
   
5.                 list.add(1);
   
6.                
   
7.                 try {
   
8.                        
   
9.                         Method add = list.getClass().getMethod("add", Object.class);
   
10.                         add.invoke(list, "abc");
    
11.                         System.out.println("Integer类型对象:   " + list.get(0));
    
12.                         System.out.println("String类型对象:   " + list.get(1));
    
13.                        
    
14.                 } catch (NoSuchMethodException | SecurityException e) {
    
15.                         e.printStackTrace();
    
16.                 } catch (IllegalAccessException e) {
    
17.                         // TODO Auto-generated catch block
    
18.                         e.printStackTrace();
    
19.                 } catch (IllegalArgumentException e) {
    
20.                         // TODO Auto-generated catch block
    
21.                         e.printStackTrace();
    
22.                 } catch (InvocationTargetException e) {
    
23.                         // TODO Auto-generated catch block
    
24.                         e.printStackTrace();
    
25.                 }
    
26.         }
    
27. 
    
28. }
    

复制代码

长见识了!

可以，泛型是在编译的时候进行的。编译的时候不能通过，如果我们避过编译时期存进去就OK 了。所以可以用反射。反射是获得字节码对象，通过字节码对象的方法存进去，能存进去，也就能取出来。