TreeSet构造方法中的 TreeSet(Comparator<? super E> comparator) ，这里面的泛型该如何理解？
在毕老师第15天的最后一个视频中关于泛型限定的讲解，代码如下：
代码中比较器class Comp implements Comparator<Person>，这里泛型设置的类型为Person类，在使用中能够接受Person和Person的子类。
而TreeSet(Comparator<? super E> comparator)构造方法中的泛型限定为只允许传入E和E的父类型。
这里我感觉有点迷糊了，请教大家该怎么理解啊？？


import java.util.*;
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 StuComp implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
  return s1.getName().compareTo(s2.getName());
}
}
class WorkerComp implements Comparator<Worker>
{
public int compare(Worker s1,Worker s2)
{
  return s1.getName().compareTo(s2.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);
}
}

楼主应给知道？和super的意思吧 ，？代表是泛型的通配符 用于元素类型无法明确时，而super就是表示父类，？super E结合起来就可以理解为缩小了不确定的范围，在E和E的父类范围内不确定，也叫泛型下限：       

下面的知识帮助楼主更上一层楼下限什么时候用？
        从集合中取出对象进行操作时，可以使用下限。比如：比较器。无论集合中的元素对象的类型是什么，只要比较器的指定的类型可以接受这些对象完成比较，就可以了。所以比较器的类型，可以是集合中当前元素的类型，也是可以该元素类型的父类型。

泛型的上限与下线 帮助楼主理解       
如果要对操作的类型进行限定，只操作一部分类型时，可以使用泛型的高级功能，泛型的限定。
        ？ Extends E：可以接收E类型和E的子类型。
        ？ SuperＥ：可以接收Ｅ了性或者Ｅ的父类型。
        实现代码：
        Public static void printCollection(Collection<? Extedns Person> coll){
        Iterator<? extends Person> it = coll.iterator();
                        while(it.hasNext()){
        //                        Student stu = it.next();
                                Person p = it.next();
                                System.out.println(p.getName()+"-----"+p.getAge());
                        }               
        }
       
什么时候使用E extends？
        一般在存储具体引用类型时使用这种情况，因为存储E类型或者E类型的子类，这时可以保证类型是安全的。
        实现代码：
        public static void main(String[] args) {
       
                        Collection<Person> coll = new ArrayList<Person>();               
                        coll.add(new Person("abc1",21));
                        coll.add(new Person("abc2",22));
                       
                        Collection<Student> coll2 = new ArrayList<Student>();
                        coll2.add(new Student("lisi1",31));
                        coll2.add(new Student("lisi2",32));
                        coll2.add(new Student("lisi3",33));
                       
                        Collection<Worker> coll3 = new ArrayList<Worker>();
                        coll3.add(new Worker("lisi11",31));
                        coll3.add(new Worker("lisi22",32));
                       
                       
                        coll.addAll(coll2);
                        coll.addAll(coll3);
                        Iterator<Person> it = coll.iterator();
                       
                        while(it.hasNext()){
                               
                                Person stu = it.next();
                                System.out.println(stu.getName());
                        }
                       
                }
       
泛型下限：
        下限什么时候用？
        从集合中取出对象进行操作时，可以使用下限。比如：比较器。无论集合中的元素对象的类型是什么，只要比较器的指定的类型可以接受这些对象完成比较，就可以了。所以比较器的类型，可以是集合中当前元素的类型，也是可以该元素类型的父类型。

泛型的限定：
                明确具体类型代表一个类型，明确？代表所有类型，
                能不能对操作的类型限制在一个范围之内呢？
               
                比如：定义一个功能，只操作person类或者person子类型。这时可以用？ 继承 E接收e类型或者E的子类型。
                存储时候就用这种方式。这就是上限。
                下限的表示形式： ？ super E;接受E类型或者E的父类型。
                                               
        什么时候使用上限呢？ 一般情况下，只要是往容器中添加元素时，使用上限 ？ extends E
        什么时候使用下限呢？一般情况下，只要是从容器中取出元素时，使用下限 ？ super E               

通配符的应用：       
                集合中使用的注意特点：保证两边一致。简单的定义方式就是保证两边类型一致，但是也有其他情况。
                泛型的通配符：？  类型不匹配时候用。当操作不同容器中类型都不确定的时候，而且使用的都是元素的从Object类中继承的方法。
                这时泛型就用通配符？来表示即可。

我上一楼的？ 代表的都是通配符啊 希望楼主看到