TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常！

那要看您是想让程序有何需求 ，还是按什么排序 对排序有什么要求，
对于同时存储有父类和子类的个人感觉还是用比较器方式排序比较好用。

写了一段有子父类存储到TreeSet的小程序
代码示例：

1. import java.util.Comparator;
   
2. import java.util.Iterator;
   
3. import java.util.TreeSet;
   
4. 
   
5. class Person{         //定义一个人对象
   
6.         private int age;
   
7.         private String name;
   
8.         Person(String name,int age)
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age=  age;
    
12.         }
    
13.         public String getName()
    
14.         {
    
15.                 return name;
    
16.         }
    
17.         public int getAge(){
    
18.                 return age;
    
19.         }
    
20. }
    
21. 
    
22. class Student extends Person   //定义一个学生对象
    
23. {
    
24.         Student(String name,int age){
    
25.                 super(name,age);
    
26.         }
    
27. }
    
28. 
    
29. public class TreeSetTest{
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 TreeSet<Person> ts = new TreeSet<Person>(new NameComparator());//将按姓名排序的比较器传给TreeSet构造函数。
    
33.                 ts.add(new Person("bcds",32));
    
34.                 ts.add(new Person("liuliu",22));
    
35.                 ts.add(new Student("asdf",32));
    
36.                 ts.add(new Student("asdf",42));
    
37.                 ts.add(new Student("egfds",42));
    
38.                
    
39.                 for(Iterator<Person> it = ts.iterator();it.hasNext();)
    
40.                 {
    
41.                         Person p = it.next();
    
42.                         System.out.println(p.getName()+".."+p.getAge());
    
43.                 }
    
44.         }
    
45. }
    
46. 
    
47. class NameComparator implements Comparator<Person> //用比较器的时候可以比子类也可以比父类，
    
48.                                                                                           //如果同时存储子父类对象的时候,要用父类的泛型进行限定。
    
49. {
    
50.         public int compare(Person p1,Person p2)
    
51.         {
    
52.                 int num = p1.getName().compareTo(p2.getName());
    
53.                 if(num==0)
    
54.                         return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
    
55.                 return num;
    
56.         }
    
57. }
    
58. 
    

复制代码

new TreeSet<Parent> 时，可以放入父类与子类，典型的 Object；
如果 new TreeSet<Child>时，就只能放子类了；比较的时候。是根据 多态的特性，子类重写了父类的 comapreTo就是使用子类的。没有则使用父类的；

1. 
   
2. import java.util.*;
   
3. 
   
4. class Person implements Comparable<Person>
   
5. {         //定义一个人对象
   
6.         private int age;
   
7.         private String name;
   
8.         Person(String name,int age)
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age=  age;
    
12.         }
    
13.         public String getName()
    
14.         {
    
15.                 return name;
    
16.         }
    
17.         public int getAge(){
    
18.                 return age;
    
19.         }
    
20.        
    
21.         public int compareTo(Person p)
    
22.         {
    
23.                 //在这里就不做比较是不是Person及其子类型了。
    
24. 
    
25.                 int num = new Integer(this.age).compareTo(new Integer(p.age));
    
26.                 if(num == 0)
    
27.                         return this.name.compareTo(p.name);
    
28.                 return num;
    
29.         }
    
30. }
    
31. 
    
32. class Student extends Person   //定义一个学生对象
    
33. {
    
34.         Student(String name,int age){
    
35.                 super(name,age);
    
36.         }
    
37. }
    
38. 
    
39. public class TreeSetTest{
    
40.         public static void main(String[] args)
    
41.         {
    
42.                 TreeSet<Person> ts = new TreeSet<Person>();
    
43.                 ts.add(new Person("bcds",32));
    
44.                 ts.add(new Person("aliuliu",22));
    
45.                 ts.add(new Student("asdf",32));
    
46.                 ts.add(new Student("fsdf",42));
    
47.                 ts.add(new Student("egfds",42));
    
48.                
    
49.                 for(Iterator<Person> it = ts.iterator();it.hasNext();)
    
50.                 {
    
51.                         Person p = it.next();
    
52.                         System.out.println(p.getName()+".."+p.getAge());
    
53.                 }
    
54.         }
    
55. }
    
56. /*直接在父类中实现Comparable复写compareTo方法，根据多态的特性实现*/
    
57. 
    

复制代码

如果问题未解决，请继续追问，如果问题解决了，请将分类改为“已解决”，谢谢