java访问权限修饰符

转自：http://www.blogjava.net/hongzionline/archive/2007/09/19/146409.html 

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

    首先声明：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类，第一句源代码都是packagejava.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(Stringargs[]) 
                    { 
                        Test te=new Test(); 
                        te.money=3000;            //合法 
                        intm=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  intmoney=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);         //非法 
          intnumber=getMoney();   //合法 
          System.out.println(number);//输出结果是10000 
         } 
          public  static  void main(Stringargs[]) 
         { 
           Son sss=new Son(); 
           sss.f(); 
          } 
      } 
  所以，访问权限修饰符权限从高到低排列是public ,protected  ,friendly, private。