1. /*
   
2. 方式一：类继承接口后指定了类型Integer
   
3. interface Inter<T>
   
4. {
   
5.         void show(T t);
   
6. }
   
7. 
   
8. class InterImpl implements Inter<Integer>
   
9. {
   
10.         public void show(Integer i)
    
11.         {
    
12.                 System.out.println(i);
    
13.         }
    
14. }
    
15. class GenericDemo5
    
16. {
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 InterImpl i = new InterImpl();
    
20.                 i.show(new Integer(88));
    
21.         }
    
22. }
    
23. */
    
24. 
    
25. //方式二：类继承接口后，还是不确定引用数据类型，继续使用泛型
    
26. interface Inter<T>
    
27. {
    
28.         <Q>void show(Q q);//泛型定义在方法上，仅仅在方法内有效
    
29. 
    
30.         void print(T t);//跟泛型类走
    
31. }
    
32. 
    
33. class InterImpl<T> implements Inter<T>
    
34. {
    
35.         public <Q> void show(Q t)//泛型跟方法走
    
36.         {
    
37.                 System.out.println(t);
    
38.         }
    
39. 
    
40.         public void print(T t)//泛型跟类走
    
41.         {
    
42.                 System.out.println("类T："+t);
    
43.         }
    
44. }
    
45. 
    
46. class GenericDemo5
    
47. {
    
48.         public static void main(String[] args)
    
49.         {
    
50.                 InterImpl<String> i = new InterImpl<String>();
    
51.                 i.show(new Integer(88));
    
52.                 i.show(new String("s88"));
    
53.                 i.print(new String("s88"));
    
54.                 //i.print(new Integer(88));//编译不能通过
    
55.         }
    
56. }
    

复制代码

所以，泛型定义在方法上是非常有好处的！