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

1. class T implements Comparable<T>{
   
2.         public int x=10;
   
3.         public T(){}
   
4.         public T(int t){
   
5.                 x = t;
   
6.         }
   
7.         @Override
   
8.         public int compareTo(T o) {
   
9.                 System.out.println("T"+x);
   
10.                 return 0;
    
11.         }
    
12. }
    
13. class TT extends T{
    
14.         public TT(int t){
    
15.                 x = t;
    
16.         }
    
17.         @Override
    
18.         public int compareTo(T o) {
    
19.                 System.out.println("TT"+x);
    
20.                 return 0;
    
21.         }
    
22. }
    
23. public class Main{
    
24.          public static void main(String[] as) {
    
25.                  TreeSet<T> set = new TreeSet<T>();
    
26.                  set.add(new T(1));
    
27.                  set.add(new TT(11));
    
28.                  set.add(new T(2));
    
29.                  set.add(new T(3));
    
30.                  set.add(new TT(20));
    
31.                  set.comparator();
    
32.          }
    
33. }
    
34. /*输出：
    
35. TT11
    
36. T2
    
37. T3
    
38. TT20
    
39. 我的理解是：按照添加的顺序，第一个和第二个比较，用后者的compareTO方法，再第二个和第三个比较，再用后者的compareTo方法。*/

复制代码

比较是一个相对的概念，但是在程序中处理的时候，是按照操作句柄来的。
比如说add(A1)，那么这里A1就是句柄。因为对add方法来说，直接产生联系的可见对象是A1，A2对于add是直接不可见的。
A1.compareTo(A2)，进行对应操作的时候会使用句柄A1的方法来处理。
所以在TreeSet中，如果需要add（A1），那么使用的就是A1的compareTo。因此每次添加的时候调用的都是“被加入”对象的compareTo。

另外从性能方面考虑，如果TreeSet中存放了继承层次更多的对象(比如5层继承)
那么当添加时，举一个例子：

TreeSet已有: A1 B1 C2 D4 E5
添加: A2

那么分别使用A1 B1 C2 D4 E5的compareTo，但是这写对象的存放位置(地址)并不一定是连续的，那搜索这些对象的时间就成了开销。
如果使用的是A2的compareTo，那么每次就需要该A2的compareTo，省去了搜索的时间开销。
当然一个集合中数据量大的时候，才会有所体现。并且这部分只是个人理解，还望指正。

希望能和楼主交流~