Java访问权限之Protected

发表于 | 分类于 |

Java访问权限之Protected

有的没的

示例来自于Java 访问权限控制_CSDN，然后个人感觉原文很详细但是解释的不太自洽，自行解释了一下。

可见性规则

  • 基类的protected成员是包内可见的，并且对子类可见；
    • （自己实现的类，仅包内以及子类可见）
  • 若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。
    • （不同包时继承得到的方法只能由自己和自己的父类可见）
    • （不同包时继承得到的方法，自己只能看见自己的方法）

示例分析

示例一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//示例一
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 son = new Son11();    
        son11.f(); // Compile OK     ----（3）
        son11.clone(); // Compile Error     ----（4）
    }
}

(1)(3)：f()从父类Father1处继承，Test1与Father1同包→Compile OK

(2)(4)：clone()从Object类（间接）继承而来，Son1的clone()只有自己以及自己的父类(Father1)可见，Test1不可见→Compile Error

示例二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//示例二
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(); // Complie OK         ----（2）
    }
}

(1)：clone()由MyObject2 自己实现，自己以及子类(Test2)可见→Compile Error

(2)：clone()从父类MyObject2继承， 只有自己以及自己的父类(MyObject2)可见→Compile OK

示例三

1
2
3
4
5
6
7
8
9
10
11
12
//示例三
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()从Object类（间接）继承而来，只有自己以及自己的父类(Test3)可见→Compile OK

示例四

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//示例四
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自己实现，只有自己、包内以及自己子类可见，Test4是它的父类→Compile Error

示例五

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//示例五
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()由MyObject4自己实现，只有自己、包内以及自己子类可见，Test5属于p5→Compile OK

实例六

1
2
3
4
5
6
7
8
9
10
//示例六
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()从Object（间接）继承而来，只有自己以及自己的父类(Test6)可见→Compile OK

示例七

1
2
3
4
5
6
7
8
9
10
11
12
//示例七
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继承而来，只有自己以及自己的父类可见→Compile Error