Java protected 关键字详解

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

• 基类的 protected 成员是包内可见的，并且对子类可见；
• 若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的 protected 方法。

我们可以通过以下几个关于 protected 方法可见性的例子来进一步掌握 protected 关键字。在碰到涉及 protected 成员的调用时，首先要确定出该 protected 成员来自何方，其可见性范围是什么，然后就可以判断出当前用法是否可行了，看下面七个例子：

实例 1

package p1;
public class Father1 {
    protected void f() {}    // 父类Father1中的protected方法
}

package p1;
public class Son1 extends Father1 {}

package p11;
public class Son11 extends Father1{}

package p1;
public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK     ----（1）
        son1.clone(); // Compile Error     ----（2）

        Son11 son11 = new Son11();
        son11.f(); // Compile OK     ----（3）
        son11.clone(); // Compile Error     ----（4）
    }
}

对于上面的示例，首先看（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

package p2;
class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

package p22;
public class Test2 extends MyObject2 {
    public static void main(String args[]) {
        MyObject2 obj = new MyObject2();
        obj.clone(); // Compile Error ----（1）
        Test2 tobj = new Test2();
        tobj.clone(); // Compile OK ----（2）
    }
}

对于（1）而言，clone() 方法来自于类 MyObject2 本身，因此其可见性为包 p2 及 MyObject2 的子类，虽然 Test2 是 MyObject2 的子类，但在 Test2 中不能访问基类 MyObject2 的 protected 方法 clone()，因此编译不通过；对于（2）而言，由于在 Test2 中访问的是其本身实例的从基类 MyObject2 继承来的 clone()，因此编译通过。

实例 3

package p3;
class MyObject3 extends Test3 {
}

package p33;
public class Test3 {
    public static void main(String args[]) {
        MyObject3 obj = new MyObject3();
        obj.clone(); // Compile OK ------（1）
    }
}

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

实例 4

package p4;
class MyObject4 extends Test4 {
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package p44;
public class Test4 {
    public static void main(String args[]) {
        MyObject4 obj = new MyObject4();
        obj.clone(); // Compile Error -----（1）
    }
}

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

实例 5

package p5;
class MyObject5 {
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

public class Test5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        MyObject5 obj = new MyObject5();
        obj.clone(); // Compile OK ----(1)
    }
}

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

实例 6

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）而言，clone() 方法来自于类 Test6，因此其可见性为包 p6 及其子类 MyObject6，而类 Test6 也在包 p6 中，因此满足可见性，编译通过。

实例 7

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）而言，clone() 方法来自于类 Object，因此该 clone() 方法可见性为包 java.lang 及其子类 Test7，由于类 MyObject7 不在此范围内，因此不满足可见性，编译不通过。