Java5泛型——仅仅是编译时检查

用代码说话：

1. package orz.caikanxp;
3. import java.util.ArrayList;
4. import java.util.List;
6. import org.junit.Test;
8. public class TestGeneric {
9.     
10.     // 创建一个ArrayList对象
11.     private Object list = new ArrayList();
12.     
13.     // 声明3个类型参数各不相同的List变量引用。
14.     private List oList = (List) this.list;
15.     private List<String> sList = (List<String>) this.list;
16.     private List<Boolean> bList = (List<Boolean>) this.list;
17.     
18.     // 用于测试的3种不同类型的数据
19.     private Object o = new Object();
20.     private String s = "hello";
21.     private Boolean b = true;
23.     // 无编译错误，有警告——未提供类型参数
24.     @Test
25.     public void testListAdd() throws Exception {
26.         this.oList.add(o);
27.         this.oList.add(s);
28.         this.oList.add(b);
29.     }
31.     // 注释的语句有会有编译错误——类型不匹配
32.     @Test
33.     public void testStringListAdd() throws Exception {
34.         // this.sList.add(o);
35.         this.sList.add(s);
36.         // this.sList.add(b);
37.     }
39.     // 注释的语句有会有编译错误——类型不匹配
40.     @Test
41.     public void testBooleanListAdd() throws Exception {
42.         // this.bList.add(o);
43.         // this.bList.add(s);
44.         this.bList.add(b);
45.     }
46.     
47.     // 编译运行均正常
48.     @Test
49.     public void testListGet() throws Exception {
50.         // 先往ArrayList对象中添加测试数据
51.         this.testListAdd();
52.         // 取出数据并使用Object类型变量引用。
53.         Object o0 = this.oList.get(0);
54.         Object o1 = this.oList.get(1);
55.         Object o2 = this.oList.get(2);
56.         
57.         System.out.println("testListGet");
58.         System.out.println(o0.getClass());
59.         System.out.println(o1.getClass());
60.         System.out.println(o2.getClass());
61.         System.out.println();
62.     }
63.     
64.     // 编译正常，运行时抛出异常——java.lang.ClassCastException
65.     // 引用变量的声明类型为String，取出数据的实际运行时类型为Object
66.     @Test
67.     public void testStringListGet0() throws Exception {
68.         this.testListAdd();
69.         String s0 = this.sList.get(0);
70.         
71.         System.out.println("testStringListGet0");
72.         System.out.println(s0.getClass());
73.         System.out.println();
74.     }
76.     // 编译运行均正常
77.     // 引用的变量声明类型和取出数据的实际运行时类型均为String
78.     @Test
79.     public void testStringListGet1() throws Exception {
80.         this.testListAdd();
81.         String s1 = this.sList.get(1);
82.         
83.         System.out.println("testStringListGet1");
84.         System.out.println(s1.getClass());
85.         System.out.println();
86.     }
87.     
88.     // 编译正常，运行时抛出异常——java.lang.ClassCastException
89.     // 引用变量的声明类型为String，取出数据的实际运行时类型为Boolean
90.     @Test
91.     public void testStringListGet2() throws Exception {
92.         this.testListAdd();
93.         String s2 = this.sList.get(2);
94.         
95.         System.out.println("testStringListGet2");
96.         System.out.println(s2.getClass());
97.         System.out.println();
98.     }
99.     
100.     // 编译运行均正常
101.     // 引用变量的声明类型为根超类Object，任何实际运行时类型都能引用
102.     @Test
103.     public void testStringListGetObject() throws Exception {
104.         this.testListAdd();
105.         Object o0 = this.sList.get(0);
106.         Object o1 = this.sList.get(1);
107.         Object o2 = this.sList.get(2);
108.         
109.         System.out.println("testStringListGetObject");
110.         System.out.println(o0.getClass());
111.         System.out.println(o1.getClass());
112.         System.out.println(o2.getClass());
113.         System.out.println();
114.     }
115.     
116.     // 要从List<String>中取出Boolean数据该怎么办呢？
117.     @Test
118.     public void testStringListGetBoolean() throws Exception {
119.         this.testListAdd();
121.         // 这种强制转换行不通，方法返回的声明类型是String，引用变量的类型是Boolean
122.         // 编译器会检查发现Boolean不是String子类，没有继承关系不允许强制转换。
123.         // Boolean b2 = (Boolean)this.sList.get(2);
125.         // 可以通过这个办法回避囧……
126.         // 先用临时根超类变量引用
127.         Object o2 = this.sList.get(2);
128.         // 再对临时根超类变量进行转换
129.         Boolean b2 = (Boolean) o2;
130.         
131.         // 结果证明取出的值确实是Boolean类型
132.         System.out.println("testStringListGetBoolean");
133.         System.out.println(b2.getClass());
134.         System.out.println();
135.     }
136. }

JUnit4测试输出结果：

1. testListGet
2. class java.lang.Object
3. class java.lang.String
4. class java.lang.Boolean
6. testStringListGet1
7. class java.lang.String
9. testStringListGetObject
10. class java.lang.Object
11. class java.lang.String
12. class java.lang.Boolean
14. testStringListGetBoolean
15. class java.lang.Boolean

注意：

上面的代码第11行创建的ArrayList对象未指定类型参数；但是即使指定了类型参数，运行的结果也是完全相同的！

因为创建的对象与“类型参数”是无关的，唯一的不同是编译时返回的“声明类型”。

甚至可以把11行换成如下语句，运行的结果和之前也是完全一致的，而不会报错：

11.     private Object list = new ArrayList<java.util.Date>();

结论：

Java5中泛型仅仅是编译时检查的，要小心使用哦。