//TreeSet(Comparator<? super E> comparator)
//                传E或E的父类型，即可比较E类型
Student和Worker都继承Person类，但是毕老师day15-13里面的比较器指定是Person类型
如下：
class comp implements Comparator<Person>
而使用的时候是Person的子类，而不是上面说的
“传E或E的父类型，即可比较E类型”
疑问中.........
TreeSet<Student> as = new TreeSet<Student>(new comp());

TreeSet<Worker> ts = new TreeSet<Worker>(new comp());

你把“定义泛型”和“使用泛型”搞反了。
定义比较器的时候，你把泛型限定为“动物”，那你使用该比较器的时候，用来对“狗”或者“猫”进行比较不可以吗？
“狗”和“猫”都是“动物”的子类。

因为TreeSet(Comparator<? super E> comparator) 这句指定了可以接受E类型还有super类型的
如下是毕老师的代码：
class GenericDemo7
{
        public static void main(String[] args)
        {
                TreeSet<Student> ts = new TreeSet<Student>(new Comp());
                ts.add(new Student("abc03"));
                ts.add(new Student("abc02"));
                ts.add(new Student("abc06"));
                ts.add(new Student("abc01"));
               
                Iterator<Student> it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next().getName());
                }
               

                TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
                ts1.add(new Worker("wabc--03"));
                ts1.add(new Worker("wabc--02"));
                ts1.add(new Worker("wabc--06"));
                ts1.add(new Worker("wabc--01"));

                Iterator<Worker> it1 = ts1.iterator();
                while(it1.hasNext())
                {
                        System.out.println(it1.next().getName());
                }
        }
}

class Comp implements Comparator<Person>
{
        public int compare(Person p1,Person p2)
        {
                return p2.getName().compareTo(p1.getName());
        }
}

class Person
{
        private String name;
        Person(String name)
        {
                this.name = name;
        }
        public String getName()
        {
                return name;
        }
        public String toString()
        {
                return "person :"+name;
        }
}

class Student extends Person
{
        Student(String name)
        {
                super(name);
        }

}

class Worker extends Person
{
        Worker(String name)
        {
                super(name);
        }
}
在代码中Student类和Worker类都继承了父类Person
所以TreeSet(Comparator<? super E> comparator)这句说明了可以使用子类或者父类都可以进行比较

泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限
class Student implements Comparable<Person>//<? super E>
{
public int compareTo(Person s)
{
  this.getName()
}
}
这样写也就可以实现比较器。

赵玮_Tom 发表于 2012-5-19 11:23
你把“定义泛型”和“使用泛型”搞反了。
定义比较器的时候，你把泛型限定为“动物”，那你使用该比较器的 ...

好像也是，没把定义泛型和使用泛型分开，不过也很容易搞混啊，不好区别