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。