1. /*
   
2. 泛型的限定2
   
3. 下限<? super E>
   
4. 
   
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.         
    
27. 
    
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. }

复制代码

在集合TreeSet(Comparator<? super E> comparator) 构造方法中，是可以传E和E的父类型
但是在你的代码中，TreeSet()传比较器的时候并未指定泛型
如果你传：new comp<?super person>，那么该集合只接受person类或者person的父类类型
         

天下 发表于 2013-10-16 00:16
在集合TreeSet(Comparator

嗯，谢谢你的回答，但在本实例中，TreeSet<?>中泛型的父类是Person，那么也就是说父类是固定的，那么是不是理解为是上限的例子会更好一些，也就是<? extends Person>？

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

1. class Com<T> implements Comparator<T>{
   
2. 
   
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>();

复制代码