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

/* compareTo其实就是依次比较两个字符串ASC码。如果两个字符串完全一样，则返回0。
* 父类中使用了compareTo方法，那么子类继承的时候会覆写父类中的方法。
* 也就是说子类中也就不能存在自己的compareTo方法。如果同时放入父类和子类的实例对象
* 比较的是父类中的compareTo方法。
*
*/
class Parent implements Comparable {
    private int age = 0;
    public Parent(int age){
       this.age = age;
    }
    public int compareTo(Object o) {
       System.out.println("method of parent");
       Parent o1 = (Parent)o;
       return age>o1.age?1:age<o1.age?-1:0;
    }
}
class Child extends Parent{
    public Child(){
       super(3);
    }
    public int compareTo(Object o) {
           System.out.println("method of child");
           Parent o1 = (Parent)o;//传入的是父类对象的实例
//           Child o1 = (Child)o;//调用的也是父类的compareTo
           return 1;
    }
}
public  class Test10 {
    public static void main(String[] args) {
       TreeSet set = new TreeSet();
       set.add(new Parent(3));
       set.add(new Child());
       set.add(new Parent(4));
       System.out.println(set.size());
    }
}

放入谁，就是 谁.compareTo(set里的元素)
有多态的情况下，符合多态的方法调用规则。

1. import java.util.Set;
   
2. import java.util.TreeSet;
   
3. 
   
4. public class TestOne {
   
5.         public static void main(String[] args){
   
6.                 Fu f = new Fu("f");
   
7.                 Zi z = new Zi("z");
   
8.                 Fu f1 = new Fu("f1");
   
9.                 Fu f2 = new Zi("f2");        //多态
   
10.                 Zi z1 = new Zi("z1");
    
11.                
    
12.                 Set set = new TreeSet();
    
13.                
    
14.                 System.out.println("=======================================放入父类对象f：");
    
15.                 set.add(f);
    
16.                 System.out.println();
    
17.                
    
18.                 System.out.println("=======================================放入子类对象z：");
    
19.                 set.add(z);
    
20.                 System.out.println();
    
21.                
    
22.                 System.out.println("=======================================放入父类对象f1：");
    
23.                 set.add(f1);
    
24.                 System.out.println();
    
25.                
    
26.                 System.out.println("=======================================放入父类引用指向子类对象f2：");
    
27.                 set.add(f2);
    
28.                 System.out.println();
    
29.                
    
30.                 System.out.println("=======================================放入子类对象z1：");
    
31.                 set.add(z1);
    
32.                 System.out.println();
    
33.                
    
34.     }
    
35. }
    
36. 
    
37. class Fu implements Comparable {
    
38.        
    
39.         String quoteName;
    
40.        
    
41.         public Fu(String quoteName) {
    
42.                 this.quoteName = quoteName;
    
43.         }
    
44.        
    
45.         @Override
    
46.         public String toString() {
    
47.                 return this.quoteName;
    
48.         }
    
49.        
    
50.         public int compareTo(Object obj) {
    
51.                 System.out.println(this.quoteName+" compareTo "+((Fu)obj).quoteName+"，调用父类compareTo方法");
    
52.                 return this.quoteName.compareTo(((Fu)obj).quoteName);
    
53.         }
    
54. }
    
55. 
    
56. 
    
57. class Zi extends Fu {
    
58.        
    
59.         public Zi(String quoteName) {
    
60.                 super(quoteName);
    
61.         }
    
62.        
    
63.         @Override
    
64.         public int compareTo(Object obj) {
    
65.                 System.out.println(this.quoteName+" compareTo "+((Fu)obj).quoteName+"，调用子类compareTo方法");
    
66.                 return this.quoteName.compareTo(((Fu)obj).quoteName);
    
67.         }
    
68. }

复制代码

拿去跑一下就清楚了。

1. =======================================放入父类对象f：
   
2. f compareTo f，调用父类compareTo方法
   
3. 
   
4. =======================================放入子类对象z：
   
5. z compareTo f，调用子类compareTo方法
   
6. 
   
7. =======================================放入父类对象f1：
   
8. f1 compareTo f，调用父类compareTo方法
   
9. f1 compareTo z，调用父类compareTo方法
   
10. 
    
11. =======================================放入父类引用指向子类对象f2：
    
12. f2 compareTo f1，调用子类compareTo方法
    
13. f2 compareTo z，调用子类compareTo方法
    
14. 
    
15. =======================================放入子类对象z1：
    
16. z1 compareTo f1，调用子类compareTo方法
    
17. z1 compareTo z，调用子类compareTo方法

复制代码

另外，LZ，compareTo不是比较ASC码啊，compareTo是你自己写的方法，你写什么它就比较什么。
除了（它是Comparable接口所要求的方法，TreeSet会调用这个方法）之外，compareTo跟普通的方法没什么区别，具有一般方法在继承和重写下的通用特性啊。
有继承和重写的情况下，就遵循继承和重写的规则。

m313786372 发表于 2014-8-12 06:03
放入谁，就是 谁.compareTo(set里的元素)
有多态的情况下，符合多态的方法调用规则。

明白了，谢谢

m313786372 发表于 2014-8-12 06:19
另外，LZ，compareTo不是比较ASC码啊，compareTo是你自己写的方法，你写什么它就比较什么。
除了（它是Comp ...

谢了。。。。。。。