Muchos libros que presentan el lenguaje Java (incluido "Pensar en Java") explican protected de manera bastante simple, básicamente con una frase, que es:Los miembros modificados por protected son visibles para su propio paquete y sus subclases.Esta afirmación es demasiado vaga y a menudo puede causar malentendidos. En realidad, la visibilidad de protected radica en dos puntos:

  • Los miembros protected de la clase base son visibles dentro del paquete y visibles para las subclases;
  • Si la subclase y la clase base no están en el mismo paquete, entonces, en la subclase, una instancia de la subclase puede acceder a los métodos protected heredados de la clase base, pero no puede acceder a los métodos protected de una instancia de la clase base.

Podemos dominar mejor la palabra clave protected mediante los siguientes ejemplos sobre la visibilidad de los métodos protected. Al encontrarnos con una llamada que involucre miembros protected, primero debemos determinar de dónde proviene el miembro protected y cuál es su ámbito de visibilidad, y luego podemos juzgar si el uso actual es viable. Veamos los siguientes siete ejemplos:

Ejemplo 1

package p1; public class Father1 { protected void f() {} //Métodos protected en la clase padre Father1 } 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) } }

Para el ejemplo anterior, primero observe (1) y (3), donde el método f() se hereda de la clase Father1, su visibilidad es el paquete p1 y sus subclases Son1 y Son11, y como la clase Test1 que llama al método f() también está en el paquete p1, la compilación en (1) y (3) pasa. Luego observe (2) y (4), donde la visibilidad del método clone() es el paquete java.lang y todas sus subclases. Para las sentencias "son1.clone();" y "son11.clone();", sus métodos clone() son visibles en las clases Son1 y Son11, pero no visibles para Test1, por lo tanto la compilación en (2) y (4) falla.

Ejemplo 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(); // Complie OK ----(2) } }

En cuanto a (1), el método clone() proviene de la propia clase MyObject2, por lo que su visibilidad es el paquete p2 y las subclases de MyObject2. Aunque Test2 es una subclase de MyObject2, en Test2 no puede acceder al método protected clone() de la clase base MyObject2, por lo que la compilación falla. En cuanto a (2), como en Test2 se accede al método clone() heredado de la clase base MyObject2 a través de su propia instancia, la compilación pasa.

Ejemplo 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) } }

En cuanto a (1), el método clone() proviene de la clase Test3, por lo que su visibilidad es el paquete p33 y su subclase MyObject3, y (1) se llama precisamente en la clase Test3 que está en p33, perteneciendo al mismo paquete, por lo que la compilación pasa.

Ejemplo 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) } }

En cuanto a (1), el método clone() proviene de la clase MyObject4, por lo que su visibilidad es el paquete p4 y sus subclases (aquí no hay subclases), pero la clase Test4 está en el paquete p44, por lo que no cumple con la visibilidad y la compilación falla.

Ejemplo 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) } }

En cuanto a (1), el método clone() proviene de la clase MyObject5, por lo que su visibilidad es el paquete p5 y sus subclases (aquí no hay subclases), y la clase Test5 también está en el paquete p5, por lo que cumple con la visibilidad y la compilación pasa.

Ejemplo 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) } }

En cuanto a (1), el método clone() proviene de la clase Test6, por lo que su visibilidad es el paquete p6 y su subclase MyObject6, y la clase Test6 también está en el paquete p6, por lo que cumple con la visibilidad y la compilación pasa.

Ejemplo 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 { }

En cuanto a (1), el método clone() proviene de la clase Object, por lo que la visibilidad de este método clone() es el paquete java.lang y su subclase Test7. Dado que la clase MyObject7 no está en este ámbito, no cumple con la visibilidad y la compilación falla.

Fuente del artículo: http://blog.csdn.net/justloveyou_/article/details/61672133