java protected修饰符说明

1. 简介

对protected修饰符进行阐述，结合Object类的clone方法进行说明。其中clone方法如下：protected Object Object.clone()；

关于protected修饰符的访问权限如下：

• 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

• 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，子类不能访问基类实例的protected方法。

2. 示例

2.1 示例1

 1 package modify.pack1;
 2 public class FaObject1 {
 3     protected void sp(){
 4         System.out.println("father method");
 5     }
 6 }
 7 
 8 
 9 package modify.pack1;
10 public class SonObject1 extends FaObject1{
11     public static void main(String[] args){
12 
13         SonObject1 sb1 = new SonObject1();
14         sb1.sp();          //  （1）
15 
16         FaObject1 fb = new FaObject1();
17         fb.sp();          //   （2）
18     }
19 }
20 
21 
22 package modify.pack2;
23 import modify.pack1.FaObject1;
24 public class SonObject2 extends FaObject1 {
25     public static void main(String[] args){
26 
27         SonObject2 sb2 = new SonObject2();
28         sb2.sp();             //  （3）
29 
30         FaObject1 fb = new FaObject1();
31 //        fb.sp();            //  （4）编译错误
32     }
33 }
34 
35 
36 package modify.pack2;
37 import modify.pack1.FaObject1;
38 public class UnrelatedObject {
39     public static void main(String[] args){
40         
41         FaObject1 fb = new FaObject1();
42 //    fb.sp();       // (5) 编译错误
43     }
44 }

解释说明如下：

（1）FaObject1和SonObject1在同一个包内，子类实例可以访问自身继承的sp方法，编译通过；

（2）FaObject1和SonObject1在同一个包内，子类可以访问父类实例的sp方法，编译通过；

（3）FaObject1和SonObject2不在同一个包内，子类实例可以访问自身继承的sp方法，编译通过；

（4）FaObject1和SonObject2不在同一个包内，子类不可以访问父类实例的sp方法，编译错误；

（5）FaObject1和UnrelatedObject不在同一个包内，该类不可以访问其他类实例的protected方法，编译错误；

 2.2 示例2

 1 package modify.pack3;
 2 public class FaObject3 {
 3     public static void main(String[] args){
 4 
 5         FaObject3 fb3 = new FaObject3();
 6         try {
 7             fb3.clone();      // (1)
 8         }
 9         catch (CloneNotSupportedException e) {
10             e.printStackTrace();
11         }
12 
13         SonObject3 sb3 = new SonObject3();
14         try {
15             sb3.clone();      // (2)
16         }
17         catch (CloneNotSupportedException e) {
18             e.printStackTrace();
19         }
20     }
21 }
22 
23 
24 package modify.pack3;
25 public class SonObject3 extends FaObject3{
26     public static void main(String[] args){
27 
28         SonObject3 sb3 = new SonObject3();
29         try {
30             sb32.clone();      // (3)
31         }
32         catch (CloneNotSupportedException e) {
33             e.printStackTrace();
34         }
35 
36         FaObject3 fb3 = new FaObject3();
37 //        fb3.clone();       // (4) 编译错误
38     }
39 }

（1）Object和FaObject3不在同一个包内，子类实例可以访问继承Object类的clone方法，编译通过；

（2）FaObject3和SonObject3在同一个包内，子类实例可以访问继承FaObject3类的clone方法，编译通过；

（3）FaObject3和SonObject3在同一个包内，子类实例可以访问继承FaObject3类的clone方法，编译通过；

（4）fb3的clone方法来自于Object类，该方法的可见性为java.lang包和Object类的FaObject3子类，对于SonObject3类不可见，因此编译错误；

！！！

转载于:https://www.cnblogs.com/jfl-xx/p/10676386.html