黑马程序员技术交流社区

标题: 关于高级泛型下限的问题 [打印本页]
作者: 王飚    时间: 2013-10-15 19:21
标题: 关于高级泛型下限的问题
本帖最后由 王飚 于 2013-10-16 18:02 编辑
  1. /*
  2. 泛型的限定2
  3. 下限<? super E>

  5. 关于老师在视屏中的讲解，说这个例子是泛型下限的例子。
  6. 但是泛型的下限不是<? super E>也就是子类对象是确定啊，
  7. 但是在这个例子中的比较器Comp却是Person(父类)的类型，
  8. 这点我很迷惑，求解答
  9. */
  10. import java.util.*;
  11. class GenericDemo_6
  12. {
  13.         public static void main(String[] args)
  14.         {
  15.         
  16.         TreeSet<Student> ts1= new TreeSet<Student>(new Comp());
  17.         ts1.add(new Student("ab01"));
  18.         ts1.add(new Student("ab03"));
  19.         ts1.add(new Student("ab02"));
  20.         ts1.add(new Student("ab04"));
  21.         Iterator it1=ts1.iterator();
  22.         while(it1.hasNext())
  23.                 {
  24.         System.out.println(it1.next());
  25.                 }
  26.         

  28.         TreeSet<Worker> ts= new TreeSet<Worker>(new Comp());
  29.         ts.add(new Worker("ab---w01"));
  30.         ts.add(new Worker("ab---w03"));
  31.         ts.add(new Worker("ab---w02"));
  32.         ts.add(new Worker("ab---w04"));
  33.         Iterator it=ts.iterator();
  34.         while(it.hasNext())
  35.                 {
  36.         System.out.println(it.next());
  37.                 }
  38.         }
  39. }
  40. class Person
  41. {
  42.         private String name;
  43.         Person(String name)
  44.         {
  45.         this.name=name;
  46.         }
  47.         public String getName()
  48.         {
  49.         return name;
  50.         }
  51.         public String toString()
  52.         {
  53.         return "Person"+name;
  54.         }
  55. }
  56. //定义父类类型的比较器就可以传入不同的子类对象了
  57. class Comp implements Comparator<Person>
  58. {
  59.         public int compare(Person p1,Person p2)
  60.         {        
  61.         return p2.getName().compareTo(p1.getName());//倒序
  62.         }
  63. }
  64. /*
  65. //比较器
  66. 发现这样写比较麻烦，因为每要存储一个对象都要写一个新的比较器
  67. class WorkComp implements Comparator<Worker>
  68. {
  69.         public int compare(Worker s1,Worker s2)
  70.         {
  71.         return s1.getName().compareTo(s2.getName());
  72.         }
  73. }
  74. //Worker的比较器
  75. class Comp implements Comparator<Worker>
  76. {
  77.         public int compare(Worker s1,Worker s2)
  78.         {
  79.         return s1.getName().compareTo(s2.getName());
  80.         }
  81. }
  82. */
  83. class Student extends Person
  84. {
  85.         Student(String name)
  86.         {
  87.         super(name);
  88.         }
  89. }
  90. class Worker extends Person
  91. {
  92.         Worker(String name)
  93.         {
  94.         super(name);
  95.         }
  96. }
复制代码
作者: 天下    时间: 2013-10-16 00:16
本帖最后由 天下 于 2013-10-16 00:17 编辑

在集合TreeSet(Comparator<? super E> comparator) 构造方法中，是可以传E和E的父类型
但是在你的代码中，TreeSet()传比较器的时候并未指定泛型
如果你传：new comp<?super person>，那么该集合只接受person类或者person的父类类型
         
作者: 王飚    时间: 2013-10-16 12:36
天下 发表于 2013-10-16 00:16
在集合TreeSet(Comparator

嗯，谢谢你的回答，但在本实例中，TreeSet<?>中泛型的父类是Person，那么也就是说父类是固定的，那么是不是理解为是上限的例子会更好一些，也就是<? extends Person>？
作者: oath    时间: 2013-10-16 15:54
本帖最后由 oath 于 2013-10-16 16:02 编辑

那要看你怎么定义比较器了，
如果定义比较器时就明确类型参数的话，实例化比较器就和泛型没有关系了
就如同你上面写的那样
还有一种情况是定义比较器时不明确类型参数，在实例化比较器的时候就要明确类型参数，明确类型参数时可以使用通配符<? super T>这样的形式作为类型参数。
举个例子
  1. class Com<T> implements Comparator<T>{

  3.         @Override
  4.         public int compare(T o1, T o2) {
  5.                 // TODO Auto-generated method stub
  6.                 return 0;
  7.         }
  8. }
复制代码
创建对象的时候就是这样
  1. Com<? super Student> comparator = new Com<Person>();
复制代码




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