JAVA里protected属性和方法的完整测试

先说几个protected的使用原则，后面再看对应的例子。

1. protected 的属性和方法可以在本包和子类访问
2. 非同包的子类里面，不能直接使用父类，或者其它包的子类访问

我们看代码，这个是基类

1. package  test.base;
3. /**
4.  * 基类，属性和方法都是protected的。
5.  *
6.  * @author 赵学庆，Java世纪网(java2000.net)
7.  *
8.  */
9. public   class  Base {
10.    protected   int  testInt;
11.    public   int  publicInt;
12.    protected   int  getTestInt() {
13.      return  testInt;
14.   }
15. }

下面是2个同一个包的测试代码，一个是普通类，1个是子类。

1. package  test.base;
3. /**
4.  * 测试相同包的子类。
5.  *
6.  * @author 赵学庆，Java世纪网(java2000.net)
7.  *
8.  */
9. public   class  TestSamePackageSubClass  extends  Base {
10.    public   void  test() {
11.     Base b =  new  Base();  // 使用基类
12.     b.publicInt =  0 ;  // 可以访问
13.     b.testInt =  1 ;  // 访问protected的属性成功
14.     b.getTestInt();  // 访问protected的方法成功
15.   }
17.    public   void  test2() {
18.     publicInt =  0 ;  // 可以访问
19.     testInt =  2 ;  // 子类中可以直接用父类的属性
20.     getTestInt();  // 子类中可以直接用父类的方法
21.   }
22. }

 

1. package  test.base;
3. /**
4.  * 测试相同包的普通类。
5.  *
6.  * @author 赵学庆，Java世纪网(java2000.net)
7.  *
8.  */
9. public   class  TestSamePackageNormal {
11.    public   void  test() {
12.     Base b =  new  Base();  // 使用基类
13.     b.publicInt =  0 ;  // 可以访问
14.     b.testInt =  1 ;  // 访问protected的属性成功
15.     b.getTestInt();  // 访问protected的方法成功
16.   }
17. }

下面是不同包的普通类和子类测试，一个普通类，2个子类

1. package  test.sub1;
3. import  test.base.Base;
5. /**
6.  * 不同包的正常类。
7.  *
8.  * @author 赵学庆，Java世纪网(java2000.net)
9.  *
10.  */
11. class  TestOtherPackageNormal {
12.    public   void  test() {
13.     Base b =  new  Base();  // 使用基类
14.     b.publicInt =  0 ;  // 可以访问
15.     b.testInt =  1 ;  // 访问protected的属性-失败
16.     b.getTestInt();  // 访问protected的方法-失败
17.   }
19.    public   void  test3() {
20.     TestOtherPackageSubClass b =  new  TestOtherPackageSubClass();
21.     b.publicInt =  0 ;  // 可以访问
22.     b.testInt =  3 ;  // 直接访问属性-失败
23.     b.getTestInt();  // 直接访问方法-失败
24.   }
25. }

1. package  test.sub1;
3. import  test.base.Base;
4. import  test.sub2.TestOtherPackage2SubClass;
6. /**
7.  * 不同包的子类1.
8.  *
9.  * @author 赵学庆，Java世纪网(java2000.net)
10.  *
11.  */
12. class  TestOtherPackageSubClass  extends  Base {
13.    public   void  test() {
14.     Base b =  new  Base();  // 使用基类
15.     b.publicInt =  0 ;  // 可以访问
16.     b.testInt =  1 ;  // 访问protected的属性失败
17.     b.getTestInt();  // 访问protected的方法失败
18.   }
20.    public   void  test2() {
21.     publicInt =  0 ;  // 可以访问
22.     testInt =  2 ;  // 直接用父类的属性-成功
23.     getTestInt();  // 直接用父类的方法-成功
24.   }
26.    public   void  test3() {
27.      // 用另外一个package的子类。
28.     TestOtherPackageSubClass2 b =  new  TestOtherPackageSubClass2();
29.     b.publicInt =  0 ;  // 可以访问
30.     b.testInt =  1 ;  // 访问protected的属性-失败
31.     b.getTestInt();  // 访问protected的方法-失败
32.   }
34.    public   void  test4() {
35.      // 用另外一个package的子类。
36.     TestOtherPackage2SubClass b =  new  TestOtherPackage2SubClass();
37.     b.publicInt =  0 ;  // 可以访问
38.     b.testInt =  1 ;  // 访问protected的属性-失败
39.     b.getTestInt();  // 访问protected的方法-失败
40.   }
41. }

1. package  test.sub1;
3. import  test.base.Base;
5. /**
6.  * 不同包的子类2.
7.  *
8.  * @author 赵学庆，Java世纪网(java2000.net)
9.  *
10.  */
11. class  TestOtherPackageSubClass2  extends  Base {
12. }

另一个不同包的子类

1. package  test.sub2;
3. import  test.base.Base;
5. /**
6.  * 另一个不同包的子类。
7.  *
8.  * @author 赵学庆，Java世纪网(java2000.net)
9.  *
10.  */
11. public   class  TestOtherPackage2SubClass  extends  Base {
13. }

总结一下：

1. 公共属性总能访问，呵呵，这个不用说了
2. 同一包的子类，可以任意使用
3. 同一个包的正常类，可以直接用他的实例进行访问
4. 不同包的正常类，无法访问任何属性和方法
5. 不同包的子类，不能使用父类实例的属性和方法
6. 不同包的子类，不能使用其它包的子类实例的属性和方法
7. 不同包的子类，可以直接使用父类的属性和方法

总之，不同包的子类就规规矩矩的在自己的代码里用父类的属性就行了。其它的使用都是不允许的。