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. class StuComp implements Comparator<Student>
    
43. {
    
44.         public int compare(Student s1,Student s2)
    
45.         {
    
46.                 return s1.getName().compareTo(s2.getName());
    
47.         }
    
48. }
    
49. 
    
50. class WorkerComp implements Comparator<Worker>
    
51. {
    
52.         public int compare(Worker s1,Worker s2)
    
53.         {
    
54.                 return s1.getName().compareTo(s2.getName());
    
55.         }
    
56. }
    
57. */
    
58. 
    
59. class Comp implements Comparator<Person>
    
60. {
    
61.         public int compare(Person p1,Person p2)
    
62.         {
    
63.                 return p2.getName().compareTo(p1.getName());
    
64.         }
    
65. }
    
66. 
    
67. 
    
68. class Person
    
69. {
    
70.         private String name;
    
71.         Person(String name)
    
72.         {
    
73.                 this.name = name;
    
74.         }
    
75.         public String getName()
    
76.         {
    
77.                 return name;
    
78.         }
    
79.         public String toString()
    
80.         {
    
81.                 return "person :"+name;
    
82.         }
    
83. }
    
84. 
    
85. class Student extends Person
    
86. {
    
87.         Student(String name)
    
88.         {
    
89.                 super(name);
    
90.         }
    
91. 
    
92. }
    
93. 
    
94. class Worker extends Person
    
95. {
    
96.         Worker(String name)
    
97.         {
    
98.                 super(name);
    
99.         }
    
100. }

复制代码

首先给毕老师视频中的原代码
泛型限定有个概念

Class person{}

Class student extends person{}

假设student是Person的子类，person是父类

如果只想要接收person和person的子类，那么可以给一个泛型限定<? extends person>

如果只想要接收student和它的父类型，那么可以给一个泛型限定<? super student>
api文档中，TreeSet的构造方法里传入的一个带泛型限定的比较器

我要怎么理解里面的这个泛型限定？
先说说毕老师的说法，老师选中图片中划了红线的区域的E说，TreeSet里存的是worker,这里就写worker，TreeSet里存的是Student，这里就写Student，这样很麻烦，然后毕老师说可以写他们的父类型，即Person，那么这个比较器就可以接收Person和person的子类对象了
毕老师视频中写的比较器的泛型限定就是

1. class Comp implements Comparator<Person>
   
2. {
   
3.         public int
   
4. compare(Person p1,Person p2)
   
5.         {
   
6.                 return
   
7. p2.getName().compareTo(p1.getName());
   
8.         }
   
9. }

复制代码

那这样就可以比较同时比较Person对象，Person的子类Student对象，Person的子类worker对象，这我明白
但是，TreeSet的构造方法TreeSet（Comparator<？ super E > comparator ）里面的这个参数泛型限定该怎么理解
我的理解是比较器的泛型限定传入了Person，比较器默认把Person传入替代了E，变成Comparator<? super Person>,但是根据<? super Person>的概念，就说明，这个比较器可以接收Person和person的父类，但明显person本身就是父类了，不对啊
如果不是这样理解，那为什么不像下面这样定义比较器,而要像上面那样定义比较器呢？

1. class Comp implements Comparator<? super Person>
   
2. {
   
3.         public int compare(Person p1,Person p2)
   
4.         {
   
5.         return p2.getName().compareTo(p1.getName());
   
6.         }
   
7. }

复制代码

斗胆潇洒 发表于 2013-10-21 00:48
呵呵，从api手册入手，有理有据，哥们真棒，加油，
我已被黑马26期录取，现在往后看着，顺 ...

我准备27期就去考，28期去上，共勉！！!

Jim-剣◆﹏ 发表于 2013-10-21 00:03
哥们，非常感谢你分析得那么详细，和大家讨论这些疑惑，我的理解也加深
我也说说我现在的理解，和你交换 ...

:D:handshake
呵呵，从api手册入手，有理有据，哥们真棒，加油，
我已被黑马26期录取，现在往后看着，顺带回答问题当复习，
有什么想要交流的，可以找我哦，黑马见:victory:

斗胆潇洒 发表于 2013-10-20 00:44
道友，看了这贴，我怎么觉得有点不对劲啊，泛型的上下限的定义是精辟的语句，按定义的那种理解才是正确的， ...

哥们，非常感谢你分析得那么详细，和大家讨论这些疑惑，我的理解也加深
我也说说我现在的理解，和你交换一下
首先看看treeSet的API文档介绍
和传入比较器的treeSet构造方法TreeSet(Comparator<? super E> comparator)
和add(E e)方法

TreeSet<E>这里面的一个E代表着存入的对象的类型，和构造TreeSet(Comparator<? super E> comparator) 里比较器里的E是同一个E，和add(E e)里的也是同一个E，也就是说，假设Student继承Person,Person是父类，Student是子类，我再定义 一个和Person和Student无关的worker类，如果我用在创建TreeSet容器的时候，这样写TreeSet<Student> treeSet = new TreeSet<Student>()，那么此时E就已经确定了，E用Student替代了，上面说了比较器里的和add里的E是同一个E，那么API文档里比较器这样写Comparator<? super E>，是为了提示我们随着E确定，比较器里能接收的对象也就随之确定了，此时比较器只能这样写Comparator<? super Student>或者Comparator<Student>或者Comparator<Person>而不能写Comparator<Worker>
add(E e)就更加明确了，TreeSet<Student> treeSet = new TreeSet<Student>()--->add(student stu),TreeSet的泛型定义的接收什么类型就是为add()这种方法提供限定的。其实说白了，这里的E就好比数学上解题的时候设的一个未知数“X”，使用时“X”确定了，往方法里代入就可以了。
哥们进黑马了吗？

道友，看了这贴，我怎么觉得有点不对劲啊，泛型的上下限的定义是精辟的语句，按定义的那种理解才是正确的，
另外，对于TreeSet<E>一旦你明确了E，如String，那么add时只能添加String，不可能add一种类型，又add它的子或父类类型，
本身Integr和String就是Object的子类，加泛型定住一个类型，就是为了保证运行时安全性，所以我觉得别试图将<? super E>以add能添加不同子父类型来验证。还有，那个<? super E>就按定义那样理解就行了，即接收E或E的父类，只是没有写出那种例子而已，我试了试，这个应该可以
先我们来确定<? super E>中的E，如图：


当我们不写MyComp的<>时，它会有警告，你看一下就知道E是什么了，Sun是我定义的孙子类，是TreeSet<Sun>的，MyComp是个Comparator子类，例子:
import java.util.*;
public class TreeSetTest
{
                public static void main(String[] args)
        {   
                        //报错，我们发现Comparator<? super E>的格式将被填充为<Zi super Fu>，错误
                        //TreeSet<Fu> ts1 = new TreeSet<Fu>(new MyComp<Zi>());
                        
                        //正确，Comparator<? super E>填充为<Fu super Sun>和<Zi super Sun>
                        TreeSet<Sun> ts1 = new TreeSet<Sun>(new MyComp<Fu>());
                        TreeSet<Sun> ts11 = new TreeSet<Sun>(new MyComp<Zi>());
//add()方法的传入类型是为<Sun>的，这是为了统一，以保运行时安全，如果可以连着添加含有继承关系的多个类型对象，在运行时不安全的                        
                        //报错，Collection<？ extends E>的格式，将被填充为<Fu extends Zi>，错误
                        //TreeSet<Zi> ts2 = new TreeSet<Zi>(new ArrayList<Fu>());

                        //正确，Collection<? extends E>的格式，被填充为<Zi extends Fu>和<Sun extends Fu>
                        TreeSet<Fu> ts2 = new TreeSet<Fu>(new ArrayList<Zi>());
                        TreeSet<Fu> ts22 = new TreeSet<Fu>(new ArrayList<Sun>());
        }
}
class MyComp<T> implements Comparator<T>{
                public int compare(T o1, T o2) {
                        return 1;
                }
}
class Fu{}
class Zi extends Fu{
}
class Sun extends Zi{
}


看完了你的长篇，有想法的回复一下，分够，不求技术分， 只是咱俩交换了下思想的苹果，1+1 => 4个

我的理解是，对于TreeSet(Comparator<? super E> comparator)，意思就是其可以接受的可以是本身的比较方法或者其父类的比较方法，对于老毕的讲解就是你可以选择Student的比较方法，也可以采用其父类的比较方法。
对于TreeSet(Collection<? extends E> c) ，是其接收对象为E或者E的子类。

楼主我建议你写代码。TreeSet的构造函数加参：Comparator和Collection两个的用法。你会明白的。

楼主,如果你的问题解决了就把帖子状态改为提问结束吧,谢谢了

阿里策 发表于 2013-10-18 20:18
我的理解是，对于TreeSet(Comparator

昨晚想到现在，经你一点就明白，瞬间豁然开朗。之前思维存在定势

    我的理解是，对于TreeSet(Comparator<? super E> comparator)，这里Comparator<? super E>中<>肩括号里面传入的是E或者是E的父类，使用时都可以接收E的对象。
    所以，你的代码class Comp implements Comparator<Person>，肩括号中传入的是Person，也就是说传入的是Student的父类，所以可以接收到Student的对象。同理，传入的Person也是Worker的父类，所以也可以接收到Worker的对象。
    对于TreeSet(Collection<? extends E> c) ，肩括号中传入的是E 或者是E的子类，使用中都可以接受E的对象。所以你可以验证：当TreeSet使用集合泛型时，传入的是Worker或者Student时，都是可以接收到Person对象的。
   

TreeSet（Comparator<？ super E > comparator ）的意思是比较器可比较本身的和父类的都可

1. import java.util.Comparator;
   
2. import java.util.Iterator;
   
3. import java.util.TreeSet;
   
4. 
   
5. public class Test {
   
6.         class Person {
   
7.                 private String name;
   
8. 
   
9.                 public String getName() {
   
10.                         return name;
    
11.                 }
    
12.                 public void setName(String name) {
    
13.                         this.name = name;
    
14.                 }
    
15.         }
    
16.         class Student extends Person{
    
17.                 void study(){
    
18.                         System.out.println("学习");
    
19.                 }
    
20.         }
    
21.         /*
    
22.          * TreeSet（Comparator<？ super E > comparator ）的意思是比较器可比较本身的和父类的都可，如下例：泛型Student
    
23.          * 可用，比的是父类的比较器CompP,和本身的CompS比较器
    
24.          * 下面为测试：
    
25.          * */
    
26.         public static void main(String[] args) {
    
27.                 Test test=new Test();
    
28.                 TreeSet<Person> t1 = new TreeSet<Person>(test.new CompP());//test.newCompS()子类比较器不行
    
29.                 Person p1=test.new Person();
    
30.                 p1.name="张三";
    
31.                 t1.add(p1);
    
32.                 /*加入子类对象，将不能比较，所以加不了,加入则报错，必定*/
    
33.                 //Student s1=test.new Student();
    
34.                 //t1.add(s1);
    
35.                 Iterator<Person> it1=t1.iterator();
    
36.                 while(it1.hasNext()){
    
37.                         System.out.println("Person父类TreeSet："+it1.next().getName());
    
38.                 }
    
39.                
    
40.                 TreeSet<Student> t2=new TreeSet<Student>(test.new CompP());//当然用子类比较器也可
    
41.                 Student s2=test.new Student();
    
42.                 s2.setName("李四");
    
43.                 t2.add(s2);
    
44.                 Iterator<Student> it2=t2.iterator();
    
45.                 while(it2.hasNext()){
    
46.                         System.out.println("Student子类TreeSet:"+it2.next().getName());
    
47.                 }
    
48.         }
    
49. 
    
50.         class CompP implements Comparator<Person> {//父类比较器
    
51.                 public int compare(Person p1, Person p2) {
    
52.                         return p2.getName().compareTo(p1.getName());
    
53.                 }
    
54.         }
    
55.         class CompS implements Comparator<Student> {//子类比较器
    
56.                 public int compare(Student s1, Student s2) {
    
57.                         return s2.getName().compareTo(s1.getName());
    
58.                 }
    
59.         }
    
60. }

复制代码

没有人看懂吗？