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

在单个类中private,protected没有什么太大的区别，但是如果继承的话，对于父类中的protected成员子类可以访问，但是private成员子类不能访问了，也就是说protected成员只对对应用程序隐藏，而private对应用程序和子类都隐藏。
首先声明：java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly。
    为了条理清晰，分三种不同情况来总结。

   一 访问权限修饰符修饰成员变量和方法
   public：表明该成员变量和方法是共有的，能在任何情况下被访问。
  
   protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了)   
       Java代码
eg:class A  
          {   
            protected int weight ;  
            protected int f( int a,int b   )     
            {  
              // 方法体  
            }  
           }   

eg:class A
          {
            protected int weight ;
            protected int f( int a,int b   )  
            {
              // 方法体
            }
           }     
       假设B与A在同一个包中，则
          Java代码
class B  
         {  
           void g()  
           {  
             A a=new A();  
             A.weight=100;//合法  
             A.f(3,4);    //合法  
            }  
          } 

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。区别在第二和第三种情况中。
     Java代码
eg: class A  
        {   
          int weight ;  
          int f( int a,int b   )     
          {  
            // 方法体  
          }  
         }    

  eg: class A
          {
            int weight ;
            int f( int a,int b   )  
            {
              // 方法体
            }
           }     
       假设B与A在同一个包中，则
          Java代码
class B  
         {  
           void g()  
           {  
             A a=new A();  
             A.weight=100;//合法  
             A.f(3,4);    //合法  
            }  
          } 

class B
          {
            void g()
            {
              A a=new A();
              A.weight=100;//合法
              A.f(3,4);    //合法
             }
           }
    private: 只能在本类中访问。
           Java代码
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);  
                    }  
                   }  
                  

  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的变量与方法不能被继承(访问)。
   Java代码
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();  
           }  
       }