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

啊呀  哥们  ，费了我好大 的功夫总算调试完了。结果就是子父类对象都是可以同时存在TreeSet集合里边的，只要你将子父类实现Comparable接口，并用正确的方法复写compareTo方法就行。具体代码如下，用来调试的友好信息也加上了，对你理解这个程序有帮助，你可以直接复制代码去运行试试

package com.zby;

import java.util.Iterator;
import java.util.TreeSet;

class Parent implements Comparable
{
        int age = 0;
        
    public Parent(int age)
    {
       this.age = age;
       System.out.println("调用父类构造函数！");
    }

    public int compareTo(Object o)
    {
           if(o instanceof Child)//如果是子类，就将object强转为子类对象.    注意：这里“判断是否是子类对象”的操作必须在前，因为，子类也是一个父类，不然，会总是跟父类比较的。
           {
                   System.out.println("子类对象跟子类对象比较");
                   Child c = (Child)o;
                   System.out.println("子类..."+this.age+" <---> 子类..."+ c.age);
                   return this.age>c.age? 1 : ( this.age==c.age ? 0 : -1);
           }
           else if(o instanceof Parent)//如果是父类，就将object强转为父类对象  如果将“判断是否是父类”的 操作放在前面，那么总会将object转换为父类，根本执行不到“判断是否是子类”的操作
           {
                   System.out.println("子类对象跟父类对象比较");
                   Parent p = (Parent)o;
                   System.out.println("子类..."+this.age+" <---> 父类..."+ p.age);
                   return this.age>p.age? 1 : ( this.age==p.age ? 0 : -1);
           }
           return 5;
    }

    @Override
    public String toString()
    {
            return "Parent...." + age;
    }
}

class Child extends Parent implements Comparable
{
        
    public Child(int age)
    {
       super(age);
       System.out.println("调用了子类构造函数！");//通过在子父类的构造函数中加入这个语句，可以清晰地看到建立子类对象的过程
    }

    public int compareTo(Object o)
    {

           if(o instanceof Child)//如果是子类，就将object强转为子类对象
           {
                   System.out.println("子类对象跟子类对象比较");
                   Child c = (Child)o;
                   System.out.println("子类..."+this.age+" <---> 子类..."+ c.age);
                   return this.age>c.age? 1 : ( this.age==c.age ? 0 : -1);
           }
           else if(o instanceof Parent)//如果是父类，就将object强转为父类对象
           {
                   System.out.println("子类对象跟父类对象比较");
                   Parent p = (Parent)o;
                   System.out.println("子类..."+this.age+" <---> 父类..."+ p.age);
                   return this.age>p.age? 1 : ( this.age==p.age ? 0 : -1);
           }
           return 5;
    }

    @Override
    public String toString()  //复写toString方法，方便输出对象信息
    {
            return "Child...." + age;
    }
}

public class TreeSetTest
{
    public static void main(String[] args)
    {
       TreeSet set = new TreeSet();

       set.add(new Parent(3));
       System.out.println("");//为了让输出结果简单明了，特地加上了空行

       set.add(new Child(8));
       System.out.println("");

       set.add(new Parent(5));
       System.out.println("");

       set.add(new Child(1));
       System.out.println("");

       set.add(new Parent(2));
       System.out.println("");

       System.out.println(set.size());
       System.out.println();

       Iterator i = set.iterator();//定义迭代器，输出set集合中的元素
       while(i.hasNext())
       {
               System.out.println(i.next());
       }
    }
}


输出结果如下：（我这里是按照年龄大小排序的）
调用父类构造函数！
父类对象跟父类对象比较
父类...3 <---> 父类...3

调用父类构造函数！
调用了子类构造函数！
子类对象跟父类对象比较
子类...8 <---> 父类...3

调用父类构造函数！
父类对象跟父类对象比较
父类...5 <---> 父类...3
父类对象跟子类对象比较
父类...5 <---> 子类...8

调用父类构造函数！
调用了子类构造函数！
子类对象跟父类对象比较
子类...1 <---> 父类...5
子类对象跟父类对象比较
子类...1 <---> 父类...3

调用父类构造函数！
父类对象跟父类对象比较
父类...2 <---> 父类...5
父类对象跟父类对象比较
父类...2 <---> 父类...3
父类对象跟子类对象比较
父类...2 <---> 子类...1

5

Child....1
Parent....2
Parent....3
Parent....5
Child....8