1. import java.util.*;
   
2. class Student implements Comparable
   
3. {
   
4.         private String name;
   
5.         private int age;
   
6.         
   
7.         public int compareTo(Object obj)
   
8.         {
   
9.                 if (!(obj instanceof Student))
   
10.                 {
    
11.                         throw new RuntimeException("No Student Class");
    
12.                 }
    
13.                 Student s = (Student)obj;
    
14. 
    
15.                 if (this.age>s.age)//这里接收的一个Object类进来，并进行强转动作，为什么能直接调用私有成员s.age
    
16.                 {
    
17.                         return 1;
    
18.                 }
    
19.                 if (this.age==s.age)
    
20.                 {
    
21.                         return this.name.compareTo(s.name);
    
22.                 }
    
23.                 return -1;
    
24.         }
    
25. 
    
26.         public Student(String name ,int age)
    
27.         {
    
28.                 this.name = name;
    
29.                 this.age = age;
    
30.         }
    
31. 
    
32.         public String getName()
    
33.         {
    
34.                 return name;
    
35.         }
    
36.         public int getAge()
    
37.         {
    
38.                 return age;
    
39.         }
    
40. }
    
41. 
    
42. class MyComparator implements Comparator
    
43. {
    
44.         public int compare(Object o1,Object o2)
    
45.         {
    
46.                 if (!(o1 instanceof Student && o2 instanceof Student))
    
47.                 {
    
48.                         throw new RuntimeException("No Student...");
    
49.                 }
    
50.                 Student s = (Student)o1;
    
51.                 Student s2 = (Student)o2;
    
52.                 int num = s.name.compareTo(s2.name);//这里同样接收的是Objcet类，也做了强转动作，为什么不能使用私有成员。他们之间区别在哪里？内存中是怎样的？
    
53.                 if (num ==0 )
    
54.                 {
    
55.                         new Integer(s.age).compareTo(new Integer(s2.age));
    
56.                 }
    
57.                 return num;
    
58.         }
    
59. }
    
60. 
    
61. class  TreeSetDemo2
    
62. {
    
63.         public static void main(String[] args)
    
64.         {
    
65.                 TreeSet ts = new TreeSet(new MyComparator());
    
66.                 ts.add(new Student ("abc",10));
    
67.                 ts.add(new Student ("bac",11));
    
68.                 ts.add(new Student ("cab",12));
    
69.                 ts.add(new Student ("acb",13));
    
70. 
    
71.                 for (Iterator it = ts.iterator();it.hasNext() ; )
    
72.                 {
    
73.                         sop(it.next());
    
74.                 }
    
75.         }
    
76.         public void sop(Object obj)
    
77.         {
    
78.                 System.out.println(obj);
    
79.         }
    
80. }

复制代码

问题详情见代码。。。。。。

私有成员只能在自己内部被访问。
if (this.age>s.age)//这里你是在Student自己的成员方法中，当然可以直接调用

而  int num = s.name.compareTo(s2.name);//此处你是在其它类中访问Student类中的私有属性,就不能直接访问到，
当你创建Student对象时在堆内存开辟空间，私有成员对外是关闭的，不能直接被访问，外部要想访问只能必须调用它给你提供的访问接口。个人见解

1. import java.util.*;
   
2. 
   
3. class Student implements Comparable
   
4. 
   
5. {
   
6. 
   
7.         private String name;
   
8. 
   
9.         private int age;
   
10. 
    
11.         
    
12. 
    
13.         public int compareTo(Object obj)
    
14. 
    
15.         {
    
16. 
    
17.                 if (!(obj instanceof Student))
    
18. 
    
19.                 {
    
20. 
    
21.                         throw new RuntimeException("No Student Class");
    
22. 
    
23.                 }
    
24. 
    
25.                 Student s = (Student)obj;
    
26. 
    
27. 
    
28. 
    
29.                 if (this.age>s.age)
    
30. 
    
31.                 {
    
32. 
    
33.                         return 1;
    
34. 
    
35.                 }
    
36. 
    
37.                 if (this.age==s.age)
    
38. 
    
39.                 {
    
40. 
    
41.                         return this.name.compareTo(s.name);
    
42. 
    
43.                 }
    
44. 
    
45.                 return -1;
    
46. 
    
47.         }
    
48. 
    
49. 
    
50. 
    
51.         public Student(String name ,int age)
    
52. 
    
53.         {
    
54. 
    
55.                 this.name = name;
    
56. 
    
57.                 this.age = age;
    
58. 
    
59.         }
    
60. 
    
61.                 public String getName()
    
62. 
    
63.         {
    
64. 
    
65.                 return name;
    
66. 
    
67.         }
    
68. 
    
69. 
    
70. 
    
71. 
    
72. }
    
73. 
    
74. 
    
75. 
    
76. 
    
77. 
    
78. class  Test25
    
79. 
    
80. {
    
81. 
    
82.         public static void main(String[] args)
    
83. 
    
84.         {
    
85. 
    
86.                 TreeSet ts = new TreeSet();
    
87. 
    
88.                 ts.add(new Student ("abc",10));
    
89. 
    
90.                 ts.add(new Student ("bac",11));
    
91. 
    
92.                 ts.add(new Student ("cab",12));
    
93. 
    
94.                 ts.add(new Student ("acb",13));
    
95. 
    
96. 
    
97. 
    
98.                 for (Iterator it = ts.iterator();it.hasNext() ; )
    
99. 
    
100.                 {
     
101. 
     
102.                        System.out.println(((Student)it.next()).getName());
     
103. 
     
104.                 }
     
105. 
     
106.         }
     
107. 
     
108.         public void sop(Object obj)
     
109. 
     
110.         {
     
111. 
     
112.                 System.out.println(obj);
     
113. 
     
114.         }
     
115. 
     
116. }

复制代码

这个Comparato方法的确很奇怪，上面我把getAge()方法给删了，没有任何影响，说明内部不需要getAge()方法来比较。 我想它可能用了反射直接获取成员的值进行对比。
至于为什么要这么做，我想可能是因为，你不能保证每一个加入集合的对象都没有私有属性，也不能保证这些对象都有getX()方法，如果就因为要加入集合而定义这个方法有点麻烦，重复。这样的话不如直接用反射，你只要有成员，继承Comparable接口就可以比较。
而如你发现的那样，Comparator却没有这个功能，是啊，到底是为什么呢？

以上只是个人暂时的意见，不对之处请见谅。

内部类要访问外部类的成员变量有两种方式，第一种外部类的成员变量有final来修饰；第二中在内部类里可以采用外部类名.this.外部类成员变量这样的方式来访问，不能直接访问，至于在内存中是什么情况，还请高手拆招

1. import java.util.*;
   
2. class Student implements Comparable
   
3. {
   
4. private String name;
   
5. private int age;
   
6. 
   
7. public int compareTo(Object obj)
   
8. {
   
9. if (!(obj instanceof Student))
   
10. {
    
11. throw new RuntimeException("No Student Class");
    
12. }
    
13. Student s = (Student)obj;
    
14. 
    
15. if (this.age>s.age)/注意注意：：：在本类中的语句当然可以用本类中的私有成员     本类中的私有成员是拒绝其他类的直接访问  但可以在本类中使用  好像黑盒子里面的东西  外面的人看不到 里面的人可以用 */
    
16. {
    
17. return 1;
    
18. }
    
19. if (this.age==s.age)
    
20. {
    
21. return this.name.compareTo(s.name);
    
22. }
    
23. return -1;
    
24. }
    
25. 
    
26. public Student(String name ,int age)
    
27. {
    
28. this.name = name;
    
29. this.age = age;
    
30. }
    
31. 
    
32. public String getName()
    
33. {
    
34. return name;
    
35. }
    
36. public int getAge()
    
37. {
    
38. return age;
    
39. }
    
40. }
    
41. 
    
42. class MyComparator implements Comparator
    
43. {
    
44. public int compare(Object o1,Object o2)
    
45. {
    
46. if (!(o1 instanceof Student && o2 instanceof Student))
    
47. {
    
48. throw new RuntimeException("No Student...");
    
49. }
    
50. Student s = (Student)o1;
    
51. Student s2 = (Student)o2;
    
52. int num = s.name.compareTo(s2.name);/*注意：在类MyComparator中不能直接使用类Student 的私有变量     因为私有了  外面的类就不能直接访问 想访问可以这样：int num=s.getName().compareTo(s2.getName()) 用类Student的方法访问Student的私有变量*/
    
53. if (num ==0 )
    
54. {
    
55. new Integer(s.age).compareTo(new Integer(s2.age));
    
56. }
    
57. return num;
    
58. }
    
59. }
    
60. 
    
61. class TreeSetDemo2
    
62. {
    
63. public static void main(String[] args)
    
64. {
    
65. TreeSet ts = new TreeSet(new MyComparator());
    
66. ts.add(new Student ("abc",10));
    
67. ts.add(new Student ("bac",11));
    
68. ts.add(new Student ("cab",12));
    
69. ts.add(new Student ("acb",13));
    
70. 
    
71. for (Iterator it = ts.iterator();it.hasNext() ; )
    
72. {
    
73. sop(it.next());
    
74. }
    
75. }
    
76. public void sop(Object obj)
    
77. {
    
78. System.out.println(obj);
    
79. }
    
80. 
    
81. }
    
82. 私有的变量 可以在本类中被访问  但不可以在本类外被直接访问
    

复制代码

楼上几位大神，我的错，应该把代码写简单点再问的，，，，，，什么内部类什么玩意的全出来了，真崩溃，有内部类吗？有反射吗？

结帖，简化一下代码重新开帖，，，，，

史政法 发表于 2013-3-1 21:01
楼上几位大神，我的错，应该把代码写简单点再问的，，，，，，什么内部类什么玩意的全出来了，真崩溃，有内 ...

我是说他内部可能用了反射原理......

刘圣繁 发表于 2013-3-1 18:37

这个最后的总结应该写成：私有的变量，可以在本类中被本类的对象引用访问，但不可以在本类外被直接访问。