黑马程序员技术交流社区

标题: 泛型接口疑问。 [打印本页]
作者: 张扬123    时间: 2012-8-17 17:08
标题: 泛型接口疑问。
本帖最后由 张扬123 于 2012-8-17 17:11 编辑
  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. }
复制代码
泛型类和泛型接口的不同又在哪呢？
作者: 刘圣伟    时间: 2012-8-17 17:24
本帖最后由 刘圣伟 于 2012-8-17 17: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的类型，所有上面不写是编译通不过的，如果把这句注释掉，上的就可以不加泛型了； ；
        }
}

泛型类定义的泛型，在整个类中有效，如果被方法使用；
  那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定
为了让不同方法可以操作不同类型，而类型还不确定；
  那么可以将泛型定义在方法上。
作者: 张扬123    时间: 2012-8-18 11:39
没有人能完整回答这个问题么。。。
作者: 左建飞    时间: 2012-8-18 12:19
我做了一下实验。
  1. package test;

  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;

  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. }
复制代码
所以泛型接口和泛型类在泛型这方面应该是没有区别的。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2