Modificadores de acceso en Java

Introducción

Los modificadores son palabras clave que nos permiten ajustar el acceso a nuestra clase y sus miembros, su alcance y comportamiento en ciertas situaciones. Por ejemplo, podemos controlar qué clases / objetos pueden tener acceso a ciertos miembros de nuestra clase, si una clase puede ser hereditaria o no, si podemos reemplazar un método más tarde, ya sea que deberíamos reemplazar un método más tarde, etc.
Las palabras clave modificadoras se escriben antes del tipo y nombre de variable / método / clase (retorno), por ejemplo, private int myVarpublic String toString().
Los modificadores en Java se dividen en uno de dos grupos: acceso y no acceso :
  • Acceso: publicprivate,protected
  • No acceso: staticfinalabstractsynchronizedvolatiletransient, ynative
¿Quieres aprender más sobre modificadores sin acceso? Echa un vistazo a nuestro artículo Modificadores sin acceso en Java .

Modificadores de acceso

Los modificadores de acceso tratan con la visibilidad de los miembros de la clase. Controlan si otras clases pueden ver o cambiar ciertas variables / métodos de nuestra clase.
Estos tipos de modificadores están estrechamente relacionados con una parte importante de la Programación Orientada a Objetos llamada encapsulación . Como recordatorio, la encapsulación es una idea que vincula los datos con el código que los manipula. Al controlar el acceso, puede evitar el mal uso.
Por ejemplo, al asegurarnos de que solo se pueda acceder a ciertas variables a través de métodos bien definidos (la combinación típica de métodos get / set) nos aseguramos de que no encontremos ningún valor inesperado o negemos el acceso externo a ciertas variables / métodos en conjunto .
Como se mencionó anteriormente, hay tres modificadores de acceso: publicprivate, y protectedJava también proporciona control de acceso predeterminado (cuando no se especifica ningún modificador), que se comporta de manera similar a protected.
  • public - Se puede acceder al miembro desde cualquier lugar.
  • protected - el miembro solo es inaccesible desde no subclases en un paquete diferente
  • predeterminado (paquete-privado) - también conocido como packageacceso, el miembro puede ser accedido por cualquier clase dentro del mismo paquete
  • private - el miembro solo puede ser accedido por otros miembros dentro de la misma clase
Esta tabla muestra todos los escenarios de acceso posibles para los miembros de la clase:
PrivadoDefectoProtegidoPúblico
Misma clase
Subclase (mismo paquete)No
No subclase (mismo paquete)No
Subclase (paquete diferente)NoNo
No subclase (paquete diferente)NoNoNo
Esta tabla se aplica solo a los miembros de la clase, no a las clases en general. Una clase no anidada solo puede ser publico sin un modificador. El comportamiento es lógico: cuando se declara una clase sin un modificador, solo se puede acceder a él mediante un código dentro del mismo paquete, y cuando se declara, publictambién se puede usar en un paquete diferente.
Nota : Una publicclase debe ser la única clase (no anidada) en el archivo, y el archivo debe tener el mismo nombre que la clase.
Por ejemplo, digamos que tenemos dos paquetes, nombrados creativamente packageOnepackageTwo.
package packageOne;

public class MyPublicClass {  
    String noModifierText = "No Modifier";
    private String privateText = "Private Text";
    protected String protectedText = "Protected Text";
    public String publicText = "Public Text";

    public MyPublicClass() {
        // We can access all members of a class from within that class
        System.out.println("MyPublicClass constructor:")
        System.out.println(noModifierText);
        System.out.println(privateText);
        System.out.println(protectedText);
        System.out.println(publicText);
    }
}
Tenga en cuenta que el código anterior se encuentra en un archivo llamado "MyPublicClass.java". El nombre debe coincidir con la clase ya que la haremos pública para que podamos acceder a ella desde un paquete diferente. Lo mismo se aplica a las otras clases a continuación.
package packageOne;

class SamePackageExtends extends MyPublicClass {  
    public SamePackageExtends() {
        System.out.println("SamePackageExtends constructor:")
        System.out.println(noModifierText);
        // Trying to access the private member privateText will fail, since private members
        // can only be accessed by members of the same class, even though this class extends it.
        // System.out.println(privateText);
        System.out.println(protectedText);
        System.out.println(publicText);
    }
}
package packageOne;

class SamePackageDoesntExtend {  
    // Has the same access as SamePackageExtends
    public SamePackageDoesntExtend() {
        MyPublicClass myPublicClass = new MyPublicClass();

        System.out.println("SamePackageDoesntExtend constructor:")
        System.out.println(myPublicClass.noModifierText);
        // System.out.println(myPublicClass.privateText);
        System.out.println(myPublicClass.protectedText);
        System.out.println(myPublicClass.publicText);
    }
}
package packageTwo;

class DifferentPackageExtends extends packageOne.MyPublicClass {  
    public DifferentPackageExtends() {
        System.out.println("DifferentPackageExtends constructor:")
        // System.out.println(noModifierText); // Same class or same package only
        // System.out.println(privateText);    // Same class only
        System.out.println(protectedText);
        System.out.println(publicText);
    }
}
package packageTwo;

class DifferentPackageDoesntExtend {  
    public DifferentPackageDoesntExtend() {
        packageOne.MyPublicClass myPublicClass = new packageOne.MyPublicClass();

        System.out.println("DifferentPackageDoesntExtend constructor:")
        // System.out.println(myPublicClass.noModifierText);
        // System.out.println(myPublicClass.privateText);
        // System.out.println(myPublicClass.protectedText); // Same package only
        System.out.println(myPublicClass.publicText);
    }
}
Consejo : es una práctica común encapsular una clase. Esto significa que declaramos las variables miembro privatey declaramos los publicmétodos que las manipulan. Por ejemplo, queremos permitir que alguien cambie de int IDcampo, pero también queremos asegurarnos de que int IDsea ​​estrictamente un número entero positivo. A pesar del método público, primero podemos ejecutar una verificación y manipular el campo si el valor dado pasa nuestra verificación. Esta es una construcción llamada set()método, y generalmente está acompañada por un get()método (ya que no podemos leer miembros privados fuera de nuestra clase) o cuando queremos controlar cómo y cuándo se puede leer el valor de una variable.
class GetSetExample {  
    ...
    private int ID = 0; // Default value
    public setID(int n) {
        if (n > 0) {
            ID = n;
        }
        else ID = 0;
    }
    public int getID() {
        // Potential read conditions that need to be met

        return ID;
    }
    ...
}
Otra cosa a tener en cuenta es que protectedes el menos utilizado de todos los modificadores de acceso. Se puede pasar por alto fácilmente si queremos. Incluso en un paquete diferente, simplemente podemos heredar la clase a cuyos protectedmiembros queremos acceder, y luego acceder a ellos a través de esa clase heredada.
Teniendo esto en cuenta, protectedse usa con más frecuencia como una guía que dice "Este miembro no está destinado a ser accedido por no subclases en un paquete diferente", por lo que aunque podemos omitir fácilmente el protectedcontrol de acceso, no es recomendable, ya que fue Lo más probable es que haya puesto allí por una razón.

Conclusión

Los modificadores son palabras clave que nos permiten ajustar el acceso a nuestra clase y sus miembros, su alcance y comportamiento en ciertas situaciones. Proporcionan rasgos fundamentales para nuestras clases y sus miembros. Todos los desarrolladores deben conocerlos a fondo para hacer el mejor uso de ellos.

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.