Java 中的权限修饰符(protected)

权限控制表
修饰词    本类    同一个包的类    继承类    其他类
private    √    ×    ×    ×
无（默认）    √    √    ×    ×
protected    √    √    √    ×
public    √    √    √    √
关于protected
最近在看Effective Java时，遇到了一个关于protected修饰符的问题。这个问题中，对于它的认识与我之前对它的认识有一些出入。所以在这里记录一下。

很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单，基本都是一句话，就是:被protected修饰的成员对于本包和其子类可见。这种说法有点太过含糊，常常会对大家造成误解。实际上，protected的可见性在于两点：

父类的protected成员是包内可见的，并且对子类可见；
若子类与父类不在同一包中，那么在子类中，子类实例可以访问其从父类继承而来的protected方法，而不能访问父类实例的protected方法。
在碰到涉及protected成员的调用时，首先要确定出该protected成员来自何方，其可见性范围是什么，然后就可以判断出当前用法是否可行。

这里有一个疑问就是上述结论的第二点。咋一看是比较绕口的，甚至有点矛盾，但是在看了下面的几个例子之后，理解就会更加深一点。

示例一
p1/Father1.java

package basic.testprotected.p1;

public class Father1 {
    protected void f() {}    // 父类Father1中的protected方法
}
1
2
3
4
5
p1/Son1.java

package basic.testprotected.p1;

public class Son1 extends Father1{}
1
2
3
p11/Son11.java

package basic.testprotected.p11;

import basic.testprotected.p1.Father1;

public class Son11 extends Father1{}
1
2
3
4
5
p1/Test1.java

首先看(1)(3)，其中的f()方法从类Father1继承而来，其可见性是包p1及其子类Son1和Son11，而由于调用f()方法的类Test1所在的包也是p1，因此（1）(3)处编译通过。也就是说，如果我们换一个包，比如Test11.java在p11下，那么将都不可访问。如下：

其次看(2)(4)，其中的clone()方法的可见性是java.lang包及其所有子类，对于语句son1.clone();和son11.clone();，二者的clone()在类Son1、Son11中是可见的，但对Test1是不可见的，因此（1）(3)处编译不通过。也就是说，如果在Son1或Son11这两个类中调用clone()方法，则是可以编译通过的。

其实到此，我所遇到的问题已基本解决。因为我遇到的情况和这里的示例代码是一模一样的。

示例二
p2/MyObject2.java

package basic.testprotected.p2;

public class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
1
2
3
4
5
6
7
p22/Test2.java

对于(1)而言，clone()方法来自于类MyObject2本身，因此其可见性为包p2及MyObject2的子类，虽然Test2是MyObject2的子类，但在Test2中不能访问父类MyObject2的protected方法clone()，因此编译不通过;对于(2)而言，由于在Test2中访问的是其本身实例的从父类MyObject2继承来的的clone()，因此编译通过。所以在这里，就很好地阐述了上面所给的第二条结论：

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

为什么要这样以及这样要如何解释呢？
我想这可能需要思考一下对子类可见的定义。先加一个构造函数，在这个构造函数里面，可以访问clone方法，这个方法来自MyObject2。

所以，再写一个类Test22继承自MyObject2，然后重新写个方法testSuperClone()，如下：

感觉这两个之间还是存在一些差距。所以，我的不太恰当理解为：对子类的实例可见，即可以在子类中，通过子类的实例去访问相应的protected方法。

示例三
p3/MyObject3.java

package basic.testprotected.p3;

import basic.testprotected.p33.Test3;

public class MyObject3 extends Test3 {}
1
2
3
4
5
p33/Test3.java

对于(1)而言，clone()方法来自于类Test3，因此其可见性为包p33及其子类MyObject3，而（1）正是在p33的类Test3中调用，属于同一包，编译通过。

示例四
p4/MyObject4.java

package basic.testprotected.p4;

import basic.testprotected.p44.Test4;

public class MyObject4 extends Test4 {
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
1
2
3
4
5
6
7
8
9
p44/Test4.java

对于(1)而言，clone()方法来自于类MyObject4，因此其可见性为包p4及其子类(此处没有子类)，而类Test4却在包p44中，因此不满足可见性，编译不通过。

示例五
p5/MyObject5.java

package basic.testprotected.p5;

public class MyObject5 {
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
1
2
3
4
5
6
7
p5/Test5.java

对于(1)而言，clone()方法来自于类MyObject5，因此其可见性为包p5及其子类(此处没有子类)，而类Test5也在包p5中，因此满足可见性，编译通过。

示例六
package p6;

class MyObject6 extends Test6{}

public class Test6 {
    public static void main(String[] args) {
        MyObject6 obj = new MyObject6();
        obj.clone();        // Compile OK   -------（1）
    }
}
1
2
3
4
5
6
7
8
9
10
对于(1)而言，clone()方法来自于类Test6，因此其可见性为包p6及其子类MyObject6，而类Test6也在包p6中，因此满足可见性，编译通过。

示例七
package p7;

class MyObject7 extends Test7 {
    public static void main(String[] args) {
        Test7 test = new Test7();
        test.clone(); // Compile Error   ----- (1)
    }
}

public class Test7 {
}
1
2
3
4
5
6
7
8
9
10
11
对于(1)而言，clone()方法来自于类Object，因此该clone()方法可见性为包java.lang及其子类Test7，由于类MyObject7不在此范围内，因此不满足可见性，编译不通过。
————————————————
版权声明：本文为CSDN博主「一条肥鱼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/asahinokawa/article/details/80777302