最近看到泛型的视频，有点点的小疑惑！泛型在C++里面  有点类似STL模板  不过C++里面是用Template关键字定义的
写法上没有JAVA的<>方便

1. package liang;
   
2. 
   
3. import java.util.*;
   
4. class Person1  
   
5. {
   
6.          private String name;
   
7.          private int age;
   
8.          
   
9. 
   
10.          Person1(String name,int age)
    
11.          {
    
12.                  this.name=name;
    
13.                  this.age=age;
    
14.          }
    
15.         /* public int compareTo(Object obj)
    
16.          {
    
17.                  if(!(obj instanceof Person))
    
18.                          throw new RuntimeException("参数不正确");
    
19.                  
    
20.                  Person p=(Person)obj;
    
21.                  if(this.age>p.age)return 1;
    
22.                  if(this.age==p.age)
    
23.                          return this.name.compareTo(p.name);
    
24.                  return -1;
    
25.          }*/
    
26.          
    
27.          public String getName()
    
28.          {
    
29.                  return name;
    
30.          }
    
31.          public int getAge()
    
32.          {
    
33.                  return age;
    
34.          }
    
35.          public void show()
    
36.          {
    
37.                  System.out.println(this.name+"..."+this.age);
    
38.          }
    
39. }
    
40. class Student1 extends Person1
    
41. {
    
42.          Student1(String name,int age)
    
43.          {
    
44.                  super(name,age);
    
45.          }
    
46. }
    
47. class Comp implements Comparator<Person1>
    
48. {
    
49.         public int compare(Person1 a,Person1 b)
    
50.         {
    
51.                 return a.getName().compareTo(b.getName());
    
52.         }
    
53. }
    
54. class GenericDemo
    
55. {
    
56.         public static void main(String[] args)
    
57.         {
    
58.                 TreeSet<Student1>s=new TreeSet<Student1>(new Comp());
    
59.                
    
60.                 s.add(new Student1("lisi00",21));
    
61.                 s.add(new Student1("lisi01",21));
    
62.                 s.add(new Student1("lisi02",21));
    
63.                 s.add(new Student1("lisi03",21));
    
64.                
    
65.                 Iterator<Student1> it =s.iterator();
    
66.                 while(it.hasNext())
    
67.                 {
    
68.                         it.next().show();
    
69.                 }
    
70.         }
    
71. }

复制代码

毕老师说泛型限定分上限和下限
<? extends E>是上限，也就是可是接收E和E的子类类型
<? super E>是下限，也就是可是接受E和E的父类类型

TreeSet(Comparator<? super E> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序。
这不是泛型下限吗？Student继承Person，程序中Comparator比较器中传入的是Person类，应该是只能接受Person类和它的父类啊！为啥子类Student可以传
谁可以给我解释下这个extends和super上下限！

哥们 你确实很细心 发现这么多

不过这个很好理解
对应TreeSet<E>
Comparetor<T>
TreeSet(Comparator<? super E> comparator)

也就是T 是那个问号 比较器传入的类型当然要是存入TreeSet中的父类才可以

osully 发表于 2014-4-22 20:30
哥们 你确实很细心 发现这么多

不过这个很好理解

谢谢大神解释！我懂了！
也就是 这个比较器Comparetor(T) 传入的类型  必须是 数据类型TreeSet(E)的父类或者自己的类型！而不是说只接受T和T的父类型是吧！