Modificadores de acceso en Java

M

Introducción

Modificadores son palabras clave que nos permiten ajustar el acceso a nuestra clase y sus miembros, su alcance y comportamiento en determinadas situaciones. Por ejemplo, podemos controlar qué clases / objetos pueden acceder a ciertos miembros de nuestra clase, si una clase puede ser heredada o no, si podemos anular un método más tarde, si deberíamos anular un método más tarde, etc.

Palabras clave modificadoras se escriben antes de la variable / método / clase (retorno) tipo y nombre, por ejemplo private int myVar o public String toString().

Los modificadores en Java se dividen en uno de dos grupos: acceso y no acceso:

  • Acceso: public, private, protected
  • Sin acceso: static, final, abstract, synchronized, volatile, transienty native

¿Desea obtener más información sobre los modificadores sin acceso? Consulte nuestro artículo Modificadores sin acceso en Java.

Modificadores de acceso

Los modificadores de acceso se ocupan de 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 encapsulamiento. 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 uso indebido.

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 encontraremos ningún valor inesperado o denegaremos el acceso externo a ciertas variables / métodos por completo .

Como se mencionó anteriormente, hay tres modificadores de acceso: public, privatey protected. Java 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 package acceso, 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:

Privado Público protegido predeterminado

Misma clasesisisisi
Subclase (mismo paquete)Nosisisi
No subclase (mismo paquete)Nosisisi
Subclase (paquete diferente)NoNosisi
No subclase (paquete diferente)NoNoNosi

Esta tabla se aplica solo a los miembros de la clase, no a las clases en general. Una clase no anidada solo puede ser public o sin un modificador. El comportamiento es lógico, cuando se declara una clase sin un modificador solo se puede acceder mediante código dentro del mismo paquete, y cuando se declara public también se puede utilizar en un paquete diferente.

Nota: UN public class 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, llamados creativamente packageOne y packageTwo.

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 está en un archivo llamado “MyPublicClass.java”. El nombre debe coincidir con la clase, ya que la haremos pública para poder acceder a ella desde un paquete diferente. Lo mismo se aplica a las otras clases siguientes.

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

Propina: Es una práctica común encapsular una clase. Esto significa que declaramos variables miembro como private y declarar public métodos que los manipulan. Por ejemplo, queremos que alguien cambie int ID campo, pero también queremos asegurarnos de que int ID es estrictamente un número entero positivo. Aunque es el 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 suele ir acompañado de un get() (ya que no podemos leer miembros privados fuera de nuestra clase) o cuándo 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 protected es el menos utilizado de todos los modificadores de acceso. Se puede omitir fácilmente si queremos. Incluso en un paquete diferente, simplemente podemos heredar la clase cuya protected miembros a los que queremos acceder, y luego acceder a ellos a través de esa clase heredada.

Con eso en mente, protected se utiliza con mayor frecuencia como una guía que dice “Este miembro no está destinado a ser accedido por personas que no sean subclases en un paquete diferente”, por lo que, aunque podemos omitir fácilmente protected control de acceso, no es recomendable, ya que lo más probable es que se haya colocado allí por alguna 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 determinadas situaciones. Proporcionan rasgos fundamentales para nuestras clases y sus miembros. Todo desarrollador debe conocerlos a fondo para aprovecharlos al máximo.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad