java访问权限修饰符public  protected  friendly private用法总结  

     首先声明：java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly。 
    为了条理清晰，分三种不同情况来总结。 

   一 访问权限修饰符修饰成员变量和方法 
   public：表明该成员变量和方法是共有的，能在任何情况下被访问。 
   
   protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了)    
       eg:class A 
          { 
            protected int weight ; 
            protected int f( int a,int b   )   
            { 
              // 方法体 
            } 
           }      
       假设B与A在同一个包中，则 
           class B 
          { 
            void g() 
            { 
              A a=new A(); 
              A.weight=100;//合法 
              A.f(3,4);    //合法 
             } 
           } 
   特别说明：什么是在同一个包中？ 
   答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子) 
       eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io; 
       没有使用package打包的，在同一目录下的类也会被视做同一个包。 
   
   friendly：在这种情况下中，同protected。区别在第二和第三种情况中。 
       eg: class A 
          { 
            int weight ; 
            int f( int a,int b   )   
            { 
              // 方法体 
            } 
           }      
       假设B与A在同一个包中，则 
           class B 
          { 
            void g() 
            { 
              A a=new A(); 
              A.weight=100;//合法 
              A.f(3,4);    //合法 
             } 
           } 
    private: 只能在本类中访问。 
             eg:    class   Test 
                    {  
                       private int money; 
                       Test() 
                       { 
                          money=2000; 
                       } 
                       private int getMoney() 
                       { 
                         return money; 
                        } 
                     public  static  void main(String args[]) 
                     { 
                         Test te=new  Test(); 
                         te.money=3000;             //合法 
                         int m=te.getMoney();       //合法 
                         System.out.println("money="+m); 
                      } 
                     } 
                   
   PS： 实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。 
    

二  访问权限修饰符修饰类 
   1，不能用protected和private修饰类。 
   2，用friendly修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。 
   

三   访问权限修饰符与继承 
   这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况： 
   1，子类与父类在同一包中 
    此时只有声明为private的变量与方法不能被继承(访问)。 
   eg: 
     class Father 
     { 
       private int money ; 
       int weight=100; 
       
      } 
     class Son extends Father 
     { 
       viod f() 
       { 
         money=10000;//   非法 
         weight=100; //   合法 
        } 
      } 
    2,子类与父类不在同一包中 
    此时private与friendly均不能被继承(访问)， protected与public可以。 
     eg: 
       Father.java 

      package com.aaa 
      public class Father 
     { 
       int height ; 
       protected  int money=120; 
       public int weight; 
       protected int getMoney() 
       { 
         return money; 
       } 
       void setMoney(int newMoney) 
       { 
         money=newMoney; 
       } 
      } 
     
      Son.java 
      package com.bbb 
      import com.aaa.Father; 
      public class Son extends Father 
      { 
         void f() 
         { 
           money=10000;//合法 
           //height=170;//非法，height为friendly修饰的变量 
           System.out.println(money);//输出结果是10000 
           //setMoney(300);          //非法 
           int number=getMoney();    //合法 
           System.out.println(number);//输出结果是10000 
          } 
           public  static  void main(String args[]) 
          { 
            Son sss=new Son(); 
            sss.f(); 
           } 
       } 
  所以，访问权限修饰符权限从高到低排列是public  ,protected  ,friendly, private。