Java protected 关键字

2022-04-20 20:04:12 阅读：212 来源： 互联网

标签：p1 Java FatherInP1 子类 clone 关键字 protected SonInP1 public

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

以访问方法为例说明第二点：

// 示例一
package p1;
public class FatherInP1 {
    protected void protectedMethod() {}    // 父类 FatherInP1 中的 protected 方法
}

package p1;
public class Son1InP1 extends FatherInP1 {}

package p2;
public class Son2InP2 extends FatherInP1{}

package p1;
public class Test {
    public static void main(String[] args) {
        Son1InP1 son1InP1 = new Son1InP1();
        son1InP1.protectedMethod(); // Compile OK     ----（1）
        son1InP1.clone(); // Compile Error     ----（2）

        Son2InP2 son2InP2 = new Son2InP2();    
        son2InP2.protectedMethod(); // Compile OK     ----（3）
        son2InP2.clone(); // Compile Error     ----（4）
    }
}

(1)(3)：其中的 protectedMethod() 方法从类 FatherInP1 继承而来，其可见性是包 p1 及其子类（Son1InP1 和 Son2InP2），由于调用 protectedMethod() 方法的类 Test 所在的包也是 p1，因此 (1)(3) 处编译通过。

(2)(4)：其中的 clone() 方法的可见性是 java.lang 包及其所有子类，对于语句 son1InP1.clone(); 和 son2InP2.clone();，二者的 clone() 在类 Son1InP1、Son2InP2 中是可见的，但对 Test 是不可见的（因为 Test 不在 java.lang 包下，只能够访问自身及其子类实例从 Object 类继承到的 clone 方法），因此 (2)(4) 处编译不通过。

// 示例二
package p1;
class FatherInP1 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}

package p2;
public class SonInP2 extends FatherInP1 {
    public static void main(String args[]) {
       FatherInP1 fatherInP1 = new FatherInP1();
       fatherInP1.clone(); // Compile Error         ----（1）

       SonInP2 sonInP2 = new SonInP2();
       sonInP2.clone(); // Compile OK         ----（2）
    }
}

(1)：clone() 方法来自于类 FatherInP1 本身，因此其可见性为包 p1 及 FatherInP1 的子类，虽然 SonInP2 是 FatherInP1 的子类，但在 SonInP2 中不能访问基类 FatherInP1 的 protected 方法 clone()（因为 SonInP2 不在 p1 包下，只能够访问其自身及其子类从 FatherInP1 类继承到的 clone 方法，而不能够访问 FatherInP1 实例及其他 FatherInP1 子类实例中受保护的 clone 方法），因此编译不通过。

(2)：由于在 SonInP2 中访问的是其本身实例从基类 FatherInP1 继承来的的 clone()，因此编译通过。

// 示例三
package p1;
class SonInP1 extends FatherInP2 {
}

package p2;
public class FatherInP2 {
  public static void main(String args[]) {
    SonInP1 sonInP1 = new SonInP1();
    sonInP1.clone();   // Compile OK     ------（1）
  }
}

(1)：clone() 方法来自于 Object 类，其可见性为包 java.lang 及其子类，子类 FatherInP2 不在 java.lang 包下，能够访问其自身及其子类从 Object 类继承到的 clone 方法，（1）正是尝试在父类 FatherInP2 中访问其子类实例继承到的 clone 方法，编译通过。

// 示例四
package p1;
class SonInP1 extends FatherInP2 {
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

package p2;
public class FatherInP2 {
  public static void main(String args[]) {
    SonInP1 sonInP1 = new SonInP1();
    sonInP1.clone(); // Compile Error      -----（1）
  }
}

(1)：clone() 方法来自于类 SonInP1，其可见性为包 p1 及其子类（此处没有子类），而类 FatherInP2 在包 p2 中且不是 SonInP1 的子类，因此不满足可见性，编译不通过。

// 示例五
package p1;

class FatherInP1 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
public class SonInP1 {
    public static void main(String[] args) throws CloneNotSupportedException {
       FatherInP1 fatherInP1 = new FatherInP1();
       fatherInP1.clone(); // Compile OK        ----(1)
    }
}

(1)：clone() 方法来自于类 FatherInP1，其可见性为包 p1 及其子类 (此处没有子类)，而类 SonInP1 也在包 p1 中，因此满足可见性，编译通过。

// 示例六
package p1;

class SonInP1 extends FatherInP1{}

public class FatherInP1 {
  public static void main(String[] args) {
    SonInP1 sonInP1 = new SonInP1();
    sonInP1.clone();        // Compile OK   -------（1）
  }
}

(1)：clone() 方法来自于类 Object，其可见性为包 java.lang 包及其子类，子类 FatherInP1 不在 java.lang 包下，能够访问其自身及其子类从 Object 类继承到的 clone 方法，而（1）正是尝试在父类 FatherInP1 中调用其子类 SonInP1 继承到的 clone 方法，编译通过。

// 示例七
package p1;

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

public class FatherInP1 { }

(1)：clone() 方法来自于类 Object，因此该 clone() 方法可见性为包 java.lang 及其子类，SonInP1 能够访问自身及其子类从 Object 继承到的 clone 方法，由于类 FatherInP1 不是 SonInP1 的子类，因此不满足可见性，编译不通过。

Demo 及主要内容来自 1，但其中的解释（至少对我来说）并不准确。

其他：2、3、4。

标签：p1,Java,FatherInP1,子类,clone,关键字,protected,SonInP1,public
来源： https://www.cnblogs.com/Higurashi-kagome/p/16171458.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Java protected 关键字