首先声明：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。