Java访问权限之protected详解

摘要&＃xff1a; 对于类的成员&＃xff08;包括成员变量和成员方法&＃xff09;而言&＃xff0c;其能否被其他类所访问&＃xff0c;取决于该成员的修饰词&＃xff1b;而对于一个类而言&＃xff0c;其能否被其他类所访问&＃xff0c;也取决于该类的修饰词。在Java中&＃xff0c;类成员访问权限修饰词有四类&＃xff1a;private&＃xff0c;无&＃xff08;包访问权限&＃xff09;&＃xff0c;protected 和 public&＃xff0c;而其中只有包访问权限和public才能修饰一个类&＃xff08;内部类除外&＃xff09;。由于很多Java书籍对protected可见性的介绍都比较笼统&＃xff0c;本文重点说明了protected关键字的可见性内涵。

对于一个类&＃xff0c;其成员&＃xff08;包括成员变量和成员方法&＃xff09;能否被其他类所访问&＃xff0c;取决于该成员的修饰词。在Java中&＃xff0c;类成员的访问权限修饰词有四个&＃xff1a;private&＃xff0c;无&＃xff08;包访问权限&＃xff09;&＃xff0c;protected 和 public&＃xff0c;其权限控制如下表所示&＃xff1a;
| | 同一个类中 | 同一个包中 | 不同包的子类 | 不同包的无关类 |
|–|–|–|–|–|–|
| public | ✔ | ✔ | ✔ | ✔ |
| protected | ✔ | ✔ | ✔ | |
| 无&＃xff08;空着不写&＃xff09; | ✔ | ✔ | | |
| private | ✔ | | | |

不同包中子类: 不同包通过继承获得关系 不同包中的无关类: 不同包通过直接创建对象来获得关系

在上面所提到的四种修饰词中&＃xff0c;除 protected 外都很好理解和掌握&＃xff0c;在此略作简述&＃xff1a;

• public &＃xff1a;被public修饰的类成员能被所有的类直接访问&＃xff1b;
• 包访问权限 &＃xff1a;包访问权限就是Java中的默认的权限&＃xff0c;具有包访问权限的类成员只能被同一包中的类访问。
• private &＃xff1a; 被public修饰的类成员只能在定义它的类中被访问&＃xff0c;其他类都访问不到。特别地&＃xff0c;我们一般建议将成员变量设为private的&＃xff0c;并为外界提供 getter/setter 去对成员变量进行访问&＃xff0c;这种做法充分体现了Java的封装思想&＃xff1b;如果你不希望其他任何人对该类拥有访问权&＃xff0c;你可以把所有的构造器都指定为private的&＃xff0c;从而阻止任何人创建该类的对象。

很多介绍Java语言的书籍(比如《Java编程思想》)都对protected做了介绍&＃xff0c;但是描述的比较简单&＃xff0c;基本都是一句话“被protected修饰的成员对于本包和其子类可见”。这种说法有点太过含糊&＃xff0c;常常会对大家造成误解。实际上&＃xff0c;protected的可见性在于以下几点&＃xff1a;

• 基类&＃xff08;父类&＃xff09;的protected成员&＃xff08;包括成员变量个成员方法&＃xff09;对本包内可见&＃xff0c;并且对子类可见&＃xff1b;
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;那么在子类中&＃xff0c;只有子类实例可以访问其从基类继承而来的protected方法&＃xff0c;而在子类中不能访问基类实例&＃xff08;对象&＃xff09;&＃xff08;所调用&＃xff09;的protected方法。
• 不论是否在一个包内&＃xff0c;父类中可以访问子类实例&＃xff08;对象&＃xff09;继承的父类protected修饰的方法。&＃xff08;子父类访问权限特点&＃xff1a;父类访问域大于子类&＃xff09;
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中,子类只能在自己的类&＃xff08;域&＃xff09;中访问父类继承而来的protected成员&＃xff0c;无法访问别的子类实例&＃xff08;即便同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;父类中不可以使用子类实例调用&＃xff08;父类中没有&＃xff09;子类中特有的&＃xff08;自己的&＃xff09;protected修饰的成员。&＃xff08;毕竟没有满足同一包内和继承获得protected成员的关系&＃xff09;

接下来我们通过下面几个关于protected方法可见性的例子进行详细解释protected关键字&＃xff1a;

示例一&＃xff1a;

// 示例一
package p1;
public class Father1 {
protected void f() {
} // 父类Father1中的protected方法
}
package p1;
public class Son1 extends Father1 {
}
package p2;
public class Son2 extends Father1{
}
package p1;
public class Test {
public static void main(String[] args) {
Son1 son1 &＃61; new Son1();
son1.f(); // Compile OK ----&＃xff08;1&＃xff09;
son1.clone(); // Compile Error ----&＃xff08;2&＃xff09;
Son2 son &＃61; new Son2();
son2.f(); // Compile OK ----&＃xff08;3&＃xff09;
son2.clone(); // Compile Error ----&＃xff08;4&＃xff09;
Test t &＃61; new Test();
t.clone; // Compile OK
// 测试类test只可以使用test类的继承Object类而来的test.clone()方法
}
}


首先看&＃xff08;1&＃xff09;&＃xff08;3&＃xff09;&＃xff0c;其中f()方法从类Father1中继承而来&＃xff0c;其可见性是包p1及其子类Son1和Son2&＃xff0c;而由于调用方法f()的类Test也在包p1之内&＃xff0c;因此&＃xff08;1&＃xff09;&＃xff08;3&＃xff09;处编译通过。 其次看&＃xff08;2&＃xff09;&＃xff08;4&＃xff09;&＃xff0c;其中clone()方法所在类为Object默认根类&＃xff0c;而Object类所在包为java.lang包。其可见性是java.lang包及其所有子类&＃xff0c;对于语句“son1.clone();”和“son11.clone();”&＃xff0c;二者的clone()在类Son1、Son2中是可见的&＃xff08;可以使用的&＃xff09;&＃xff0c;但对Test类是不可见的&＃xff0c;因此&＃xff08;1&＃xff09;&＃xff08;3&＃xff09;处编译不通过。 再者&＃xff0c;如果测试类在p2包内&＃xff0c;由于不满足protected两种可见性&＃xff08;同一包内和子父类关系&＃xff09;&＃xff0c;也将无法调用protected修饰的f()方法。test测试类在p2包内&＃xff0c;即便继承Father1类Son1和Son2也无法调用f()方法(Test t &＃61; new Test(); t.f();可以调用)&＃xff0c;因为在p2包内继承了Father1&＃xff0c;虽然不在同一包内&＃xff0c;但是现在有了子父类的关系&＃xff0c;即Test类与Son1、Son2形成了兄弟关系&＃xff0c;由于 protected受访问保护规则是很微妙的&＃xff0c;虽然protected域对所有子类都可见&＃xff0c;但是子类只能在自己的作用范围内访问自己继承的那个父类protected&＃xff0c;而无法到访问别的子类&＃xff08;同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。

子类只能在自己的作用范围&＃xff08;域&＃xff09;中访问父类protected成员&＃xff0c;无法访问别的子类实例&＃xff08;即便同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。

但是即便不在一个包里&＃xff0c;在父类中也可以访问子类实例&＃xff08;对象&＃xff09;继承的父类protected修饰的方法。

如果子父类不在一个包内&＃xff0c;父类不可以调用&＃xff08;父类中没有&＃xff09;子类中特有的&＃xff08;自己的&＃xff09;protected修饰的成员。&＃xff08;毕竟没有满足同一包内和继承获得protected成员的关系&＃xff09;

示例二

package P1;
public class MyObject {
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
package P2;
import P1.MyObject;
public class Test extends MyObject {
public static void main(String args[]) throws CloneNotSupportedException {
MyObject obj &＃61; new MyObject();
obj.clone(); // Compile Error ----&＃xff08;1&＃xff09;
Test tobj &＃61; new Test();
tobj.clone(); // Complie OK ----&＃xff08;2&＃xff09;
}
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;clone()方法来自于类MyObject本身&＃xff0c;因此其可见性为包p1及MyObject的子类&＃xff0c;虽然Test是MyObject的子类&＃xff0c;但是由于在子类中&＃xff0c;只有本类实例可以访问其从基类继承而来的protected方法&＃xff0c;而在子类中不能访问基类实例&＃xff08;对象&＃xff09;&＃xff08;所调用&＃xff09;的protected方法。&＃xff08;作为子类&＃xff0c;Test类中建立超类实例&＃xff0c;直接去访问超类的protected方法是不可以的&＃xff09;&＃xff0c;因此编译不通过。

对于&＃xff08;2&＃xff09;而言&＃xff0c;由于在Test中访问的是其本身实例的从基类MyObject继承来的的clone()&＃xff0c;因此编译通过。

示例三

package P1;
public class Test {
public static void main(String args[]) throws CloneNotSupportedException {
MyObject obj &＃61; new MyObject();
obj.clone(); // Compile OK ------&＃xff08;1&＃xff09;
}
}
package P2;
public class MyObject extends Test {
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;由于父类中可以访问子类实例&＃xff08;对象&＃xff09;继承的父类protected修饰的方法&＃xff08;子父类访问权限特点&＃xff1a;父类访问域大于子类&＃xff09;&＃xff0c;因此编译通过。

示例四

package P1;
public class Test {
public static void main(String args[]) throws CloneNotSupportedException {
MyObject obj &＃61; new MyObject();
obj.clone(); // Compile Error -----&＃xff08;1&＃xff09;
}
}
package P2;
public class MyObject extends Test {
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;clone()方法来自于类MyObject是其特有方法&＃xff0c;因此其可见性为包p2及其子类(此处没有子类)&＃xff0c;而类Test4却在包p1中&＃xff0c;因此不满足可见性&＃xff0c;编译不通过。 若子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;父类中不可以使用子类实例访问&＃xff08;父类中没有&＃xff09;子类中特有的&＃xff08;自己的&＃xff09;protected修饰的成员。&＃xff08;毕竟没有满足同一包内和继承获得protected成员的关系&＃xff09;

示例五

package P1;
public class MyObject {
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
MyObject obj &＃61; new MyObject();
obj.clone(); // Compile OK ----(1)
}
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;clone()方法来自于类MyObject&＃xff0c;因此其可见性为包p1及其子类(此处没有子类)&＃xff0c;而类Test也在包p1中&＃xff0c;因此满足可见性&＃xff0c;编译通过。

示例六

package p1;
class MyObject extends Test{
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
MyObject obj &＃61; new MyObject();
obj.clone(); // Compile OK -------&＃xff08;1&＃xff09;
}
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;clone()方法来自于类Test6&＃xff0c;因此其可见性为包p1及其子类MyObject&＃xff0c;而类Test也在包p1中&＃xff0c;因此满足可见性&＃xff0c;编译通过。

示例七

package p1;
public class Test {
}
class MyObject extends Test {
public static void main(String[] args) {
Test test &＃61; new Test();
test.clone(); // Compile Error ----- (1)
}
}


对于&＃xff08;1&＃xff09;而言&＃xff0c;首先&＃xff0c;clone()方法所在类为Object默认根类&＃xff0c;而Object类所在包为java.lang包。protected修饰的clone()方法其可见性是java.lang包及其所有子类&＃xff0c;所以可以判断clone()方法所在包与子类不在同一个包中。 其次&＃xff0c;若子类与基类不在同一包中时&＃xff0c;子类中不能访问基类实例&＃xff08;对象&＃xff09;&＃xff08;所调用&＃xff09;的protected方法。 MyObject子类访问权限只满足本类示例的访问。

示例八

package A;
public class Animal {

protected void crowl(String c){

System.out.println(c);
}
}
package B;
import A.Animal;
class Cat extends Animal
{

}
public class Rat extends Animal{

public void crowl(){

this.crowl("zhi zhi"); //没有问题&＃xff0c;继承了Animal中的protected方法——crowl(String)
Animal ani&＃61;new Animal();
ani.crowl("animail jiaojiao"); //wrong, The method crowl(String) from the type Animal is not visible
Cat cat&＃61;new Cat();
cat.crowl("miao miao"); //wrong, The method crowl(String) from the type Animal is not visible
}
}


首先判断其可见性&＃xff0c;可以看出虽然不满足同一包内&＃xff0c;但是满足子父类继承关系。 由于子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;所以在子类中&＃xff0c;只有本类实例可以访问其从基类继承而来的protected方法。而在子类中不能访问基类实例&＃xff08;对象&＃xff09;&＃xff08;所调用&＃xff09;的protected方法。而在子类中也无法访问其他子类实例&＃xff08;即便相同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。

示例九

package a;
public class A {

protected void m(){
System.out.println("A m~~~");
}
}
package b;
import a.A;
public class B extends A {
void callM() {
m();
super.m();
B b &＃61; new B();
b.m();
}
}
package b;
import a.A;
public class C extends A {
void callM() {
m();
super.m();
B b &＃61; new B();
b.m(); //The method m() from type A is not visible
}
}


因为b.m()这种调用属于子类对象调用&＃xff0c;因此&＃xff0c;当创建子类对象调用父类的protected成员变量时&＃xff0c;必须要注意&＃xff1a;子类对象和子类是对应的&＃xff01; 由上述案例总结&＃xff0c;由于子类与基类&＃xff08;父类&＃xff09;不在同一包中,子类只能在自己的类&＃xff08;域&＃xff09;中访问父类继承而来的protected成员&＃xff0c;无法访问别的子类实例&＃xff08;即便相同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。所以编译失败。

protected是最难理解的一种Java类成员访问权限修饰词。在编程中&＃xff0c;碰到涉及protected的调用时&＃xff0c;首先要确定出该protected成员来自何方&＃xff0c;其可见性范围是什么&＃xff0c;或根据下列访问特点&＃xff0c;便可以正确无误的使用了。

• 基类&＃xff08;父类&＃xff09;的protected成员&＃xff08;包括成员变量个成员方法&＃xff09;对本包内可见&＃xff0c;并且对子类可见&＃xff1b;
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;那么在子类中&＃xff0c;只有本类实例可以访问其从基类继承而来的protected方法&＃xff0c;而在子类中不能访问基类实例&＃xff08;对象&＃xff09;&＃xff08;所调用&＃xff09;的protected方法。
• 不论是否在一个包内&＃xff0c;父类中可以访问子类实例&＃xff08;对象&＃xff09;继承的父类protected修饰的方法。&＃xff08;子父类访问权限特点&＃xff1a;父类访问域大于子类&＃xff09;
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中,子类只能在自己的类&＃xff08;域&＃xff09;中访问父类继承而来的protected成员&＃xff0c;无法访问别的子类实例&＃xff08;即便相同父类的亲兄弟&＃xff09;所继承的protected修饰的方法。
• 若子类与基类&＃xff08;父类&＃xff09;不在同一包中&＃xff0c;父类中不可以使用子类实例调用&＃xff08;父类中没有&＃xff09;子类中特有的&＃xff08;自己的&＃xff09;protected修饰的成员。&＃xff08;毕竟没有满足同一包内和继承获得protected成员的关系&＃xff09;

• Java基础知识详解&＃xff1a; protected修饰符
• Java 访问权限控制&＃xff1a;你真的了解 protected 关键字吗&＃xff1f;
• The method * from the type * is not visible
• protected修饰符详解