package权限控制：

1）一个package可拆成多个*.java文件，但是一个*.java文件只能有一个public class。只有public class是对外可见的，可见意味着可以通过import关键字引用。

2）成员和方法有四种权限，private，default，protected和public，一个比一个宽松。

3）在同一个包内，default/protected和public是一回事。private不允许继承。在包外面能访问到的东西肯定是比包里面要少，因而拆包的时候很可能就会遇到权限问题。

4）比较明显的规则是private和default在包外访问不到，而public在包外能访问。主要的模糊点是protected，它是介于public和default之间的情况。在外面访问protected也不是件“容易”的事情，只有在子类中通过super能访问到。

下面是展示权限情况的两段代码，TestAuth引用TestAuth1：

1. package TestAuth1;  
2.  
3. public class A {
   //包外不可见  
4.     public int f_pub;  
5.     protected int f_prot;  
6.     int f_def;  
7.     private int f_pri;  
8.       
9.     public void show_public(){  
10.         System.out.println("show_public");  
11.     }  
12.       
13.     protected void show_protected(){
    //包外不可见 //包外子类super可见  
14.         System.out.println("show_protected");  
15.     }  
16.       
17.     void show_default(){
    //包外不可见  
18.         System.out.println("show_default");  
19.     }  
20.       
21.     private void show_private(){
    //包外不可见 //不可见  
22.         System.out.println("show_private");  
23.     }  
24. }  
25.  
26. class B extends A {
    //包外不可见  
27.     public void show(){  
28.         //super可见到3个方法  
29.         super.show_public();  
30.         super.show_protected();  
31.         super.show_default();  
32.     }  
33. } 

1. package TestAuth;  
2. import TestAuth1.A;//能见到A  
3.  
4. public class Entry {  
5.     public static void main(String args[])   
6.     {  
7.         A a = new A();//能见到1个方法  
8.         a.show_public();  
9.           
10.         B b = new B();//能见到2个方法  
11.         b.show();//通过super访问父类protected方法  
12.         b.show_public();  
13.     }  
14. }  
15.  
16. class B extends A {  
17.     void show(){  
18.         //super可见到2个方法  
19.         super.show_public();  
20.         super.show_protected();  
21.     }  
22. } 

 参考书：《Thinking in Java 3th Edition》 Bruce Eckel