java protected访问权限

今天做项目时遇到一个问题。
以为对同一包内的一个类调用另一个类的protected 方法感到很奇怪。
然以为protected 需要派生类才能访问，没想到在同一包内也能访问protected 成员。
哎！弄了 好久才明白。
我的测试代码：
基类代码：包为com.fu

[java]  view plain  copy

1. package com.fu;  
2.   
3. public class Base {  
4.       
5.         protected int protectedInt;  //protected成员  
6.         public int publicInt;        //public 成员  
7.         protected  int  getProtectedInt(){  
8.             return protectedInt;  
9.         }  
10.         protected static int staticProtectInt;  
11.         private int privateInt;  
12.         public static void main(String[] args) {  
13.             Base b=new Base();  
14.             b.privateInt=5;  
15.         }  
16. }  

不同包内派生类：com.zi

[java]  view plain  copy

1. package com.zi;  
2.   
3. import com.fu.Base;  
4.   
5. public class TestOtherPackageSubClass extends Base {  
6.     public void test() {  
7.         Base b = new Base(); // 使用基类  
8.         b.publicInt = 0; // 可以访问  
9.         <span style="color:#FF0000;">//b.protectedInt=3; // 访问protected的属性失败  
10.         //b.getProtectedInt(); // 访问protected的方法失败</span>  
11.         Base.staticProtectInt=9;  
12.     }  
13.       
14.     public void test2() {  
15.         <span style="color:#FF0000;">//privateInt =6;   //访问父类的私有-出错</span>  
16.         publicInt = 0; // 可以访问  
17.         protectedInt = 2; // 直接用父类的属性-成功  
18.         super.protectedInt=4;  
19.           
20.         getProtectedInt(); // 直接用父类的方法-成功  
21.         System.out.println("getProtectedInt-test2:"+getProtectedInt());  
22.           
23.         protectedInt = 22; // 直接用父类的属性-成功  
24.         Base.staticProtectInt=10;  
25.         super.getProtectedInt(); // 直接用父类的方法-成功  
26.         System.out.println("getProtectedInt-test2:"+getProtectedInt());  
27.     }  
28.       
29.     public void test3(){  
30.         TestOtherPackageSubClass t=new TestOtherPackageSubClass();  
31.         t.protectedInt=6;  
32.         t.getProtectedInt();  
33.         System.out.println("getProtectedInt-test3:"+t.getProtectedInt());  
34.     }  
35.       
36.     public static void main(String[] args) {  
37.         TestOtherPackageSubClass t=new TestOtherPackageSubClass();  
38.         t.test2();  
39.         System.out.println(Base.staticProtectInt);  
40.     }  
41. }  

运行结果为：
getProtectedInt-test2:4
getProtectedInt-test2:22
10
从运行结果 4,22 看出  test2 中不管有没有写super.protectInt,还是直接protectInt 都是指向父类的成员。从这可以看出不在同一包的子类可以访问父类数据成员。
而标颜色的是明显出错的。
如果把这个Base.staticProtectInt=10; 去掉的话， Base.staticProtectInt输出结果为0。因为test()方法没有调用不会设为9。

同一包内子类代买 com.fu

[java]  view plain  copy

1. package com.fu;  
2.   
3. import com.zi.TestOtherPackageSubClass;  
4.   
5. public class TestSamePackageSubClass extends Base {  
6.     public void test() {  
7.         Base b = new Base(); // 使用基类  
8.         b.publicInt = 0; // 可以访问  
9.         b.protectedInt=3; // 访问protected的属性成果  
10.         b.getProtectedInt(); // 访问protected的方法成功  
11.     }  
12.       
13.     public void test2() {  
14.         publicInt = 0; // 可以访问  
15.         protectedInt = 2; // 直接用父类的属性-成功  
16.         Base.staticProtectInt=9;  
17.         System.out.println("getProtectedInt-test2:"+getProtectedInt());  
18.     }  
19.       
20.     public void test3(){  
21.         TestOtherPackageSubClass t=new TestOtherPackageSubClass();  
22.         t.protectedInt=6;  
23.           
24.         System.out.println("getProtectedInt-test3:"+t.getProtectedInt());  
25.     }  
26.       
27.     public static void main(String[] args) {  
28.         TestSamePackageSubClass t=new TestSamePackageSubClass();  
29.         t.test2();  
30.         t.test3();  
31.           
32.     }  
33.   
34. }  

如果同一包内的话可以通过 base b.protectedInt 访问了。
同一包内非派生类：

[java]  view plain  copy

1. package com.fu;  
2.   
3. public class TestSamePackageNotSubClass {  
4.     public static void main(String[] args) {  
5.         Base b = new Base(); // 使用基类  
6.         b.publicInt = 0; // 可以访问  
7.         b.protectedInt=3;   
8.         System.out.println(b.getProtectedInt());  
9.     }  
10. }  

同一包内的话可以通过 base b.protectedInt 访问了。
从这看出同一包可以使用基类 Base b.protectedInt 访问，而不属于同一包内的派生类中只能直接使用基类super.protectedInt 或者protedtecInt，而不能通过 Base b.protectedInt 访问。
 
3种权限总结如下：
privte   :只用本类可用 
protected   :同包内均和派生类中可用  比默认[default|package]（只包内能使用） 权限大一点
public   :全部可用
在看一个代码明白protected 和package 的权限

[java]  view plain  copy

1. package com.zi;  
2.   
3. import com.fu.Base;  
4.   
5. public class TestOtherPackageNotSubClass {  
6.     public static void main(String[] args) {  
7.         System.out.println(Base.staticProtectInt); //访问出错。  
8.     }  
9. }  

TestOtherPackageNotSubClass 不能访问Base.staticProtectInt，而TestOtherPackageSubClass能够访问正说明了这一点。