Modificadores de acceso en Java

    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.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *