1. import java.util.*;
   
2. class Person
   
3. {
   
4.         private String name;
   
5.         Person(String name){
   
6.                 this.name=name;
   
7.         }
   
8. 
   
9.         public String getName(){
   
10.                 return name;
    
11.         }
    
12. }
    
13. 
    
14. class A extends Person
    
15. {
    
16.         A(String name){
    
17.                 super(name);
    
18.         }
    
19. }
    
20. 
    
21. public class Test
    
22. {
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 TreeSet<Person> ts=new TreeSet<Person>(new MyCompare());
    
26.                 ts.add(new Person("Person01"));
    
27.                 ts.add(new Person("Person04"));
    
28.                 ts.add(new Person("Person03"));
    
29. 
    
30.                 TreeSet<A> ts1=new TreeSet<A>(new MyCompare());
    
31.                 ts1.add(new A("A01"));
    
32.                 ts1.add(new A("A04"));
    
33.                 ts1.add(new A("A03"));
    
34.                
    
35.                 printTS(ts1);
    
36.         }
    
37. 
    
38.         //为什么使用<? super A>就会出现找不到：方法 getName()
    
39.         //A类和A类的父类也都有getName()方法啊。
    
40.         public static void printTS(TreeSet<? super A> ts){
    
41.                 for(Iterator<? super A> itr=ts.iterator();itr.hasNext();){
    
42.                         System.out.println(itr.next().getName());
    
43.                         //这里将getName()，改成toString()就不会有问题。
    
44.                         //那么是不是可以理解编译时找A的父类不是找到Person，而是找到了Object
    
45.                         //所以才没找到方法 getName()
    
46.                 }
    
47.         }
    
48.         /*
    
49.         //使用<? extends A>就没有问题，因为A类中有getName()方法。
    
50.         public static void printTS(TreeSet<? extends A> ts){
    
51.                 for(Iterator<? extends A> itr=ts.iterator();itr.hasNext();){
    
52.                         System.out.println(itr.next().getName());
    
53.                 }
    
54.         }
    
55.         */
    
56. 
    
57. 
    
58. }
    
59. 
    
60. class MyCompare implements Comparator<Person>
    
61. {
    
62.         public int compare(Person o1,Person o2){
    
63.                 return o2.getName().compareTo(o1.getName());
    
64.         }
    
65. }
    

复制代码

? Super A 就是说A的父类都可以 Itr.next 返回的是Object类型  要强转换成 Person就可以了 Object就没有getName方法 所以不行
? extends A 就是说A的子类都可以   Itr.next 返回的是A类型  A的类型肯定有getName方法 所以可以

public static void printTS(TreeSet<? super A> ts){
                for(Iterator<? super A> itr=ts.iterator();itr.hasNext();){
                        System.out.println(((Person)itr.next()).getName());
                        //这里将getName()，改成toString()就不会有问题。
                        //那么是不是可以理解编译时找A的父类不是找到Person，而是找到了Object
                        //所以才没找到方法 getName()
                }
        }
半你修改了下 红色的部分

    如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。
    通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。
    泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。