13、尽量隐藏类信息（对于Java访问修饰符的总结）

第十三章讲了，要将类的信息，不管是成员变量还是方法，能隐藏的尽量隐藏，引出来对于访问修饰符的几个知识点，加黄色底影的地方是以前没有清晰的搞定的地方。

首先声明：java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly，其实就是default类型。

为了条理清晰，分三种不同情况来总结。

一 访问权限修饰符修饰成员变量和方法

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

特别说明：什么是在同一个包中？

答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子)

eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io;

没有使用package打包的，在同一目录下的类也会被视做同一个包。

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

eg:

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

PS：实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

二 访问权限修饰符修饰类

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。

四 根据zimingguo同学的提示,内部类是可以用private来修饰的，同时关于这点也有很多有趣的地方，引用下子 孑大大的探讨文章来参考，http://zhangjunhd.blog.51cto.com/113473/65624。