Modificadores de acces

En Java, los modificadores de acceso se utilizan para establecer la visibilidad de las clases, métodos y atributos. Estos modificadores permiten controlar qué partes del código pueden acceder a estos elementos, promoviendo la encapsulación y protegiendo los datos de accesos no deseados.

Existen cuatro modificadores de acceso en Java:

• public
• private
• protected
• default (sin especificar modificador)

A continuación, te explico cada uno de estos modificadores con ejemplos:

---

1. public

El modificador public hace que el elemento (clase, método o atributo) sea accesible desde cualquier clase dentro del mismo proyecto o incluso desde proyectos externos si la clase es parte de una biblioteca.

Características:

• Puede ser accedido desde cualquier clase, incluso desde otras clases fuera del paquete.
• No hay restricciones en su acceso.

Ejemplo de uso del modificador public:

public class Persona {
    public String nombre;

    public void saludar() {
        System.out.println("Hola, mi nombre es " + nombre);
    }
}

public class Main {
    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.nombre = "Juan";  // Se accede directamente a la variable pública
        persona.saludar();        // Llamada al método público
    }
}

Salida esperada:

Hola, mi nombre es Juan

En este caso, tanto el atributo nombre como el método saludar() son públicos y accesibles desde cualquier parte del código, incluso desde la clase Main que está en otro lugar.

---

2. private

El modificador private restringe el acceso a la misma clase en la que está definido. Esto significa que el elemento marcado como private no puede ser accedido desde fuera de la clase, ni siquiera por las clases que heredan de ella.

Características:

• Solo es accesible dentro de la misma clase.
• Se utiliza para proteger los atributos y métodos de ser modificados o accedidos directamente desde otras clases.

Ejemplo de uso del modificador private:

public class Persona {
    private String nombre;  // Atributo privado

    private void mostrarNombre() {  // Método privado
        System.out.println("Mi nombre es " + nombre);
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;  // Método público para modificar el nombre privado
    }

    public void obtenerNombre() {
        mostrarNombre();  // Llamada al método privado desde dentro de la clase
    }
}

public class Main {
    public static void main(String[] args) {
        Persona persona = new Persona();
        // persona.nombre = "Juan";  // ERROR: no se puede acceder directamente al atributo privado
        persona.setNombre("Juan");  // Se accede al atributo privado a través de un método público
        persona.obtenerNombre();    // Llamada al método público que llama al privado
    }
}

Salida esperada:

Mi nombre es Juan

En este caso, el atributo nombre y el método mostrarNombre() son privados, por lo que no pueden ser accedidos directamente desde la clase Main. En cambio, se utiliza el método setNombre() para modificar el valor de nombre y obtenerNombre() para llamar al método privado mostrarNombre().

---

3. protected

El modificador protected permite que el elemento sea accesible dentro de la misma clase, dentro del mismo paquete y también por subclases (clases que heredan de la clase con el modificador protected), incluso si estas subclases están en un paquete diferente.

Características:

• Es accesible dentro de la misma clase y dentro del mismo paquete.
• También es accesible desde subclases, aunque estén en paquetes diferentes.

Ejemplo de uso del modificador protected:

public class Animal {
    protected String nombre;

    protected void hacerSonido() {
        System.out.println("El animal hace un sonido.");
    }
}

public class Perro extends Animal {
    public void ladrar() {
        nombre = "Perro";  // Acceso al atributo protected desde la subclase
        hacerSonido();      // Llamada al método protected desde la subclase
        System.out.println("El perro ladra.");
    }
}

public class Main {
    public static void main(String[] args) {
        Perro perro = new Perro();
        perro.ladrar();  // Llamada a un método protegido desde la subclase
    }
}

Salida esperada:

El animal hace un sonido.
El perro ladra.

En este ejemplo:

• La clase Perro hereda de Animal y puede acceder a los atributos y métodos marcados como protected en la clase base (Animal).
• nombre y hacerSonido() son accesibles dentro de la subclase Perro aunque estén en diferentes paquetes (si fuera el caso), pero no serían accesibles fuera de la jerarquía de clases o fuera del paquete sin la relación de herencia.

---

4. default (sin modificador)

En Java, cuando no se especifica un modificador de acceso, el valor predeterminado es default o paquete-privado. Esto significa que el acceso al elemento está limitado a clases dentro del mismo paquete. Es como si se usara protected dentro del paquete, pero sin extenderse a clases fuera de este.

Características:

• Es accesible solo desde otras clases dentro del mismo paquete.
• No es accesible fuera del paquete, ni desde clases que heredan de la clase.

Ejemplo de uso del modificador default (sin modificador):

public class Animal {
    String nombre;  // Modificador default

    void hacerSonido() {  // Modificador default
        System.out.println("El animal hace un sonido.");
    }
}

public class Perro {
    public void ladrar() {
        Animal animal = new Animal();
        animal.nombre = "Perro";  // Accede al atributo default porque está en el mismo paquete
        animal.hacerSonido();     // Llama al método default porque está en el mismo paquete
        System.out.println("El perro ladra.");
    }
}

public class Main {
    public static void main(String[] args) {
        Perro perro = new Perro();
        perro.ladrar();  // Accede a los miembros default de Animal
    }
}

Salida esperada:

El animal hace un sonido.
El perro ladra.

En este caso, la clase Perro está en el mismo paquete que Animal, por lo que puede acceder tanto al atributo nombre como al método hacerSonido() aunque estos no tengan un modificador de acceso explícito (es decir, están usando el modificador default). Si Main estuviera en otro paquete, no podría acceder a estos elementos.

---

Resumen de los modificadores de acceso

Modificador	Visibilidad	Uso típico
public	Accesible desde cualquier parte del código (mismo paquete o externo)	Cuando necesitas que una clase, método o atributo sea accesible desde cualquier lugar del programa.
private	Solo accesible dentro de la misma clase	Para ocultar datos internos y proteger el estado del objeto, garantizando que solo se puedan modificar mediante métodos controlados.
protected	Accesible dentro del mismo paquete y desde subclases (incluso en otros paquetes)	Cuando quieres que un método o atributo sea accesible dentro de la misma clase, subclases y dentro del mismo paquete.
default	Accesible sólo dentro del mismo paquete	Utilizado cuando se desea permitir el acceso solo dentro del paquete sin exponer el elemento fuera de él. Es el modificador por defecto.