控制可见性的访问修饰符

private--仅对本类可见
public-- 对所有类可见
protected-- 对本包和所有子类可见
默认friendly--对本包可见，但这是一种不受鼓励的形式。

访问权限修饰符权限从高到低排列是public ,protected ,friendly, private。
java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly。
分三种不同情况来总结。

一 访问权限修饰符修饰成员变量和方法
public：表明该成员变量和方法是共有的，能在任何情况下被访问。

protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了)
eg:

Java代码

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);    //合法
             }
           } 

friendly：在这种情况下中，同protected。区别在第二和第三种情况中。
Java代码

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);    //合法   
             }   
           }  

private: 只能在本类中访问。
eg:

Java代码

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);   
                      }   
                     }  

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


三 访问权限修饰符与继承
这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况：
1，子类与父类在同一包中
此时只有声明为private的变量与方法不能被继承(访问)。
eg:


Java代码

class Father   
     {   
       private int money ;   
       int weight=100;   

      } 

Java代码

class Son extends Father   
     {   
       viod f()   
       {   
         money=10000;//   非法   
         weight=100; //   合法   
        }   

2,子类与父类不在同一包中
此时private与friendly均不能被继承(访问)， protected与public可以，protected的一个说法就是希望不是同一个包的类想调用它就必须通过继承来调用，否则不能。
eg:
Father.java



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
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。