java protected修飾符說明

1. 簡介java

對protected修飾符進行闡述,結合Object類的clone方法進行說明。其中clone方法以下:protected Object Object.clone();spa

關於protected修飾符的訪問權限以下:code

  • 子類與基類在同一包中:被聲明爲 protected 的變量、方法和構造器能被同一個包中的任何其餘類訪問;blog

  • 子類與基類不在同一包中:那麼在子類中,子類實例能夠訪問其從基類繼承而來的 protected 方法,子類不能訪問基類實例的protected方法。繼承

2. 示例io

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 }

解釋說明以下:class

(1)FaObject1和SonObject1在同一個包內,子類實例能夠訪問自身繼承的sp方法,編譯經過;import

(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類不可見,所以編譯錯誤;

!!!

相關文章
相關標籤/搜索