TreeSet 文档上写的是 TreeSet(Comparator<? super E> comparator)
比较器的泛型应该是任意类型或者其父类型，但是为什么<>中写Person类是，可以在TreeSet建立时比较Student和Worker类的对象?
虽然没有写<? super E>但是写Person也应该是比较Person本身或者其父类，为什么可以比较Person类的子类？那不跟<? extends E>的功能一样了吗？
另<? super E>什么时候用呢？

下面写个程序大家好明白我问问题的意思。

1. import java.util.*;
   
2. class GenericDemo7
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                
   
7.                 TreeSet<Student> ts = new TreeSet<Student>(new Comp());
   
8. 
   
9.                 ts.add(new Student("abc03"));
   
10.                 ts.add(new Student("abc02"));
    
11.                 ts.add(new Student("abc06"));
    
12.                 ts.add(new Student("abc01"));
    
13.                
    
14.                 Iterator<Student> it = ts.iterator();
    
15. 
    
16.                 while(it.hasNext())
    
17.                 {
    
18.                         System.out.println(it.next().getName());
    
19.                 }
    
20.                 /**/
    
21. 
    
22. 
    
23. 
    
24.                 TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
    
25. 
    
26.                 ts1.add(new Worker("wabc--03"));
    
27.                 ts1.add(new Worker("wabc--02"));
    
28.                 ts1.add(new Worker("wabc--06"));
    
29.                 ts1.add(new Worker("wabc--01"));
    
30. 
    
31. 
    
32.                 Iterator<Worker> it1 = ts1.iterator();
    
33. 
    
34.                 while(it1.hasNext())
    
35.                 {
    
36.                         System.out.println(it1.next().getName());
    
37.                 }
    
38.         }
    
39. }
    
40. 
    
41. 
    
42. 
    
43. class Comp implements Comparator<Person>
    
44. {
    
45.         public int compare(Person p1,Person p2)
    
46.         {
    
47.                 return p2.getName().compareTo(p1.getName());
    
48.         }
    
49. }
    
50. 
    
51. 
    
52. class Person
    
53. {
    
54.         private String name;
    
55.         Person(String name)
    
56.         {
    
57.                 this.name = name;
    
58.         }
    
59.         public String getName()
    
60.         {
    
61.                 return name;
    
62.         }
    
63.         public String toString()
    
64.         {
    
65.                 return "person :"+name;
    
66.         }
    
67. }
    
68. 
    
69. class Student extends Person
    
70. {
    
71.         Student(String name)
    
72.         {
    
73.                 super(name);
    
74.         }
    
75. 
    
76. }
    
77. 
    
78. class Worker extends Person
    
79. {
    
80.         Worker(String name)
    
81.         {
    
82.                 super(name);
    
83.         }
    
84. }

复制代码

这是我的笔记，
你看一下，
泛型
       几个术语：
                 ArrayList<E>中的E称为类型变量或类型参数
                 整个称为ArrayList<E>泛型类型
                 整个ArrayList<Integer>称为参数化的类型
                 ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
                 ArrayList称为原始类型
        <1>.泛型要注意的几个问题
                 1.参数化类型和原始类型互不兼容
                 2.参数化类型不考虑类型参数的继承关系      
                 3.泛型不能应用于数组           
        <2>.泛型中的?通配符
                 使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无                关的方法，不能调用与参数化有关的方法。例如：不能调用ArrayList类的add()方法，但是可以调用                    ArrayList类的size()方法。
        <3>.泛型中的?通配符的扩展
                 1.限定通配符的上边界(即参数类型只能是这个类或者是继承这个类的子类):
                    示例：正确：Vector<? extends Number> x = new Vector<Integer>();
                          错误：Vector<? extends Number> x = new Vector<Date>();
                 2.限定通配符的下边界：
                          示例：Vector<? super Integer> x = new Vector<Number>();
                 注：限定通配符总是包括自己。