很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单,基本都是一句话,就是: 被 protected 修饰的成员对于本包和其子类可见。这种说法有点太过含糊,常常会对大家造成误解。实际上,protected的可见性在于两点:
- 基类的 protected 成员是包内可见的,并且对子类可见;
- 若子类与基类不在同一包中,那么在子类中,子类实例可以访问其从基类继承而来的protected方法,而不能访问基类实例的protected方法。
我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。在碰到涉及protected成员的调用时,首先要确定出该protected成员来自何方,其可见性范围是什么,然后就可以判断出当前用法是否可行了,看下面七个例子:
实例 1
1 package p1; 2 public class Father1 { 3 protected void f() {} // 父类Father1中的protected方法 4 } 5 6 package p1; 7 public class Son1 extends Father1 {} 8 9 package p11; 10 public class Son11 extends Father1{} 11 12 package p1; 13 public class Test1 { 14 public static void main(String[] args) { 15 Son1 son1 = new Son1(); 16 son1.f(); // Compile OK ----(1) 17 son1.clone(); // Compile Error ----(2) 18 19 Son11 son = new Son11(); 20 son11.f(); // Compile OK ----(3) 21 son11.clone(); // Compile Error ----(4) 22 } 23 }
对于上面的示例,首先看(1)(3),其中的f()方法从类Father1继承而来,其可见性是包p1及其子类Son1和Son11,而由于调用f()方法的类Test1所在的包也是p1,因此(1)(3)处编译通过。其次看(2)(4),其中的clone()方法的可见性是java.lang包及其所有子类,对于语句"son1.clone();"和"son11.clone();",二者的clone()在类Son1、Son11中是可见的,但对Test1是不可见的,因此(2)(4)处编译不通过。
实例 2
1 package p2; 2 class MyObject2 { 3 protected Object clone() throws CloneNotSupportedException{ 4 return super.clone(); 5 } 6 } 7 8 package p22; 9 public class Test2 extends MyObject2 { 10 public static void main(String args[]) { 11 MyObject2 obj = new MyObject2(); 12 obj.clone(); // Compile Error ----(1) 13 14 Test2 tobj = new Test2(); 15 tobj.clone(); // Complie OK ----(2) 16 } 17 }
对于(1)而言,clone()方法来自于类MyObject2本身,因此其可见性为包p2及MyObject2的子类,虽然Test2是MyObject2的子类,但在Test2中不能访问基类MyObject2的protected方法clone(),因此编译不通过;对于(2)而言,由于在Test2中访问的是其本身实例的从基类MyObject2继承来的的clone(),因此编译通过。
实例 3
1 package p3; 2 class MyObject3 extends Test3 { 3 } 4 5 package p33; 6 public class Test3 { 7 public static void main(String args[]) { 8 MyObject3 obj = new MyObject3(); 9 obj.clone(); // Compile OK ------(1) 10 } 11 }
对于(1)而言,clone()方法来自于类Test3,因此其可见性为包p33及其子类MyObject3,而(1)正是在p33的类Test3中调用,属于同一包,编译通过。
实例 4
1 package p4; 2 class MyObject4 extends Test4 { 3 protected Object clone() throws CloneNotSupportedException { 4 return super.clone(); 5 } 6 } 7 8 package p44; 9 public class Test4 { 10 public static void main(String args[]) { 11 MyObject4 obj = new MyObject4(); 12 obj.clone(); // Compile Error -----(1) 13 } 14 }
对于(1)而言,clone()方法来自于类MyObject4,因此其可见性为包p4及其子类(此处没有子类),而类Test4却在包p44中,因此不满足可见性,编译不通过。
实例 5
1 package p5; 2 3 class MyObject5 { 4 protected Object clone() throws CloneNotSupportedException{ 5 return super.clone(); 6 } 7 } 8 public class Test5 { 9 public static void main(String[] args) throws CloneNotSupportedException { 10 MyObject5 obj = new MyObject5(); 11 obj.clone(); // Compile OK ----(1) 12 } 13 }
对于(1)而言,clone()方法来自于类MyObject5,因此其可见性为包p5及其子类(此处没有子类),而类Test5也在包p5中,因此满足可见性,编译通过。
实例 6
1 package p6; 2 3 class MyObject6 extends Test6{} 4 public class Test6 { 5 public static void main(String[] args) { 6 MyObject6 obj = new MyObject6(); 7 obj.clone(); // Compile OK -------(1) 8 } 9 }
对于(1)而言,clone()方法来自于类Test6,因此其可见性为包p6及其子类MyObject6,而类Test6也在包p6中,因此满足可见性,编译通过。
实例 7
1 package p7; 2 3 class MyObject7 extends Test7 { 4 public static void main(String[] args) { 5 Test7 test = new Test7(); 6 test.clone(); // Compile Error ----- (1) 7 } 8 } 9 10 public class Test7 { 11 }
对于(1)而言,clone()方法来自于类Object,因此该clone()方法可见性为包java.lang及其子类Test7,由于类MyObject7不在此范围内,因此不满足可见性,编译不通过。
标签:Java,package,子类,clone,class,protected,public,详解 From: https://www.cnblogs.com/FangwayLee/p/17278684.html