1. interface Inter<T>
   
2. {
   
3.         void show(T t);
   
4. }
   
5. class InterImpl<T> implements Inter<T>
   
6. {
   
7.         public void show(T t)
   
8.         {
   
9.                 System.out.println("show:"+t);
   
10.         }
    
11. }
    
12. class GenericDemo5
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 InterImpl<Integer> i = new InterImpl<Integer>();//此处的泛型不加也能通过，为什么？
    
17.                 i.show(4);
    
18.         }
    
19. }

复制代码

而另一个例子，泛型类。

1. class Worker
   
2. {
   
3. }
   
4. class Student
   
5. {
   
6. }
   
7. class Utils<QQ>
   
8. {
   
9.         private QQ q;
   
10.         public void setObject(QQ q)
    
11.         {
    
12.                 this.q = q;
    
13.         }
    
14.         public QQ getObject()
    
15.         {
    
16.                 return q;
    
17.         }
    
18. }
    
19. class GenericDemo3
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.                 Utils<Worker> u = new Utils<Worker>();//此处的泛型不加就会出错，这为什么？
    
24.                 u.setObject(new Worker());
    
25.                 Worker w = u.getObject();
    
26.         }
    
27. }

复制代码

泛型类和泛型接口的不同又在哪呢？

class Worker
{
}
class Student
{
}
class Utils<QQ>
{
        private QQ q;
        public void setObject(QQ q)
        {
                this.q = q;
        }
        public QQ getObject()
        {
                return q;
        }
}
class GenericDemo3
{
        public static void main(String[] args)
        {
                Utils<Worker> u = new Utils<Worker>();<u><b>//此处的泛型不加就会出错，这为什么？</b></u>
                u.setObject(new Worker());
                Worker w = u.getObject();  //因为这个方法，返回只必须是QQ类型的，所有，就确定了，U的类型，所有上面不写是编译通不过的，如果把这句注释掉，上的就可以不加泛型了； ；
        }
}

泛型类定义的泛型，在整个类中有效，如果被方法使用；
  那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定
为了让不同方法可以操作不同类型，而类型还不确定；
  那么可以将泛型定义在方法上。

没有人能完整回答这个问题么。。。

我做了一下实验。

1. package test;
   
2. 
   
3. interface Inter<T>
   
4. {
   
5.         void show(T t);
   
6. }
   
7. class InterImpl<T> implements Inter<T>
   
8. {
   
9.         private T t;
   
10.         public void show(T t)
    
11.         {
    
12.                 System.out.println("show:"+t);
    
13.         }
    
14.         public T getObject()//此处加了一个返回值为T的方法。
    
15.         {
    
16.                 return t;
    
17.         }
    
18. }
    
19. class GenericDemo5
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.                 InterImpl/*<Integer>*/ i = new InterImpl/*<Integer>*/();//此处的泛型不加也能通过，为什么？
    
24.                 Integer a=i.getObject();//那么此处调用这个方法的时候也会出现跟下面的代码一样的错误。这是因为此处的Integer是便是T类型但是Integer从来没有声明过便被使用了。所以便会报错。这时将上面一行的注释去掉，程序便恢复正常。
    
25.                 i.show(4);
    
26.         }
    
27. }

复制代码

1. package test;
   
2. 
   
3. class Worker
   
4. {
   
5. }
   
6. class Student
   
7. {
   
8. }
   
9. class Utils<QQ>
   
10. {
    
11.         private QQ q;
    
12.         public void setObject(QQ q)
    
13.         {
    
14.                 this.q = q;
    
15.         }
    
16.         public QQ getObject()
    
17.         {
    
18.                 return q;
    
19.         }
    
20. }
    
21. class GenericDemo3
    
22. {
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 Utils u = new Utils();//此处的泛型不加就会出错，这为什么？
    
26.                 u.setObject(new Worker());
    
27.                 Worker w = u.getObject();//如果上面没有泛型，那么这句代码也会出错。也是因为Worker就是QQ类型但是就没有声明过。所以使用便会报错。
    
28.         }
    
29. }

复制代码

所以泛型接口和泛型类在泛型这方面应该是没有区别的。