黑马程序员技术交流社区

标题: 关于高级泛型下限的问题 [打印本页]

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

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

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

作者: 天下    时间: 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>{

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





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