1. class Demo11
   
2. {
   
3.         private int age;
   
4.         public Demo11(int i)
   
5.         {
   
6.                 age=i;
   
7.         }
   
8.         boolean compare(Demo11 anotherDemo)
   
9.         {
   
10.                 if (this.age==anotherDemo.age)//为什么能编译通过？这里访问到了另一个类的私有变量，麻烦解释一下？？
    
11.                     return true;
    
12.                 else
    
13.                         return false;
    
14.         }
    
15. }
    
16. 
    
17. public class TestCompare
    
18. {
    
19.         public static void main(String args[])
    
20.         {
    
21.                 Demo11 aa=new Demo11(20);
    
22.                 Demo11 cc=new Demo11(22);
    
23.                 System.out.println(aa.compare(cc)?"年龄相等":"年龄不等");
    
24.         }
    
25. 
    
26. }
    

复制代码

为什么能访问到呢？

//所谓的私有成员不能访问，是指在外部类中被访问，如下代码示例：

class Stu {

        public String name="zhangsan";
        private int age=24;
        
}

public class TestStu {
        public static void main(String[] args) {
                Stu student = new Stu();
                System.out.println(student.name);
               
                //System.out.println(student.age);  //不能被访问到        }
}

//而你所提供的代码是在Demo11类内部，所以能够访问到私有成员

• class Demo11
• {
•         private int age;
•         public Demo11(int i)
•         {
•                 age=i;
•         }
•         boolean compare(Demo11 anotherDemo)
•         {
•                 if (this.age==anotherDemo.age)   //在Demo11类内部自然就可以访问
•                     return true;
•                 else
•                         return false;
•         }
• }
  

哦，谢谢大家了，同一个类的不同对象之间可以访问对象的private成员变量和方法。原来是因为访问控制是在类的级别上，而不是在对象的级别上。

这相当于是在本类中访问自己的私有属性是不受限制的

{:soso_e101:}因为你私有化啦

1. <ol><li>class Demo11
   
2. 
   
3. </li><li>{
   
4. 
   
5. </li><li>        private int age;
   
6. 
   
7. </li><li>        public Demo11(int i)
   
8. 
   
9. </li><li>        {
   
10. 
    
11. </li><li>                age=i;
    
12. 
    
13. </li><li>        }
    
14. 
    
15. </li><li>        boolean compare(Demo11 anotherDemo)
    
16. 
    
17. </li><li>        {
    
18. 
    
19. </li><li>                if (this.age==anotherDemo.age)//该语句中anotherDemo.age，是通过Demo11创建的对象来访问自己内部的私有成员
    
20. 
    
21. </li><li>                    return true;
    
22. 
    
23. </li><li>                else
    
24. 
    
25. </li><li>                        return false;
    
26. 
    
27. </li><li>        }
    
28. 
    
29. </li><li>}
    
30. 
    
31. </li><li>
    
32. 
    
33. </li><li>public class TestCompare
    
34. 
    
35. </li><li>{
    
36. 
    
37. </li><li>        public static void main(String args[])
    
38. 
    
39. </li><li>        {
    
40. 
    
41. </li><li>                Demo11 aa=new Demo11(20);
    
42. 
    
43. </li><li>                Demo11 cc=new Demo11(22);
    
44. 
    
45. </li><li>                System.out.println(aa.compare(cc)?"年龄相等":"年龄不等");
    
46. 
    
47. </li><li>        }
    
48. 
    
49. </li><li>
    
50. 
    
51. </li><li>}</li></ol>

复制代码

使用private修饰的成员，只能在本类中访问，而你的if (this.age==anotherDemo.age)中，a
notherDemo是Demo11创建的对象，anotherDemo.age是通过对象访问自己内部的私有成员，
这样是能够访问的。

许庭洲 发表于 2012-7-18 16:22
class Demo11
{
        private int age;//私有字段age

技术分这么多:funk:

class Demo11
{
        private int age;//私有字段age
        public Demo11(int i)
        {
                 age=i;
         }
        boolean compare(Demo11 anotherDemo)
        {
                if (this.age==anotherDemo.age)//在本类中的方法当然有权限访问本类的私有字段了。
                     return true;
                else
                         return false;
         }
}

被private修飾的成員變量在本類中是可以被訪問的.在其他類中就不可以了.