Modificadores de acceso en Java

Hola a todos, hoy os explicare el funcionamiento de los modificadores de acceso en Java.

Hasta ahora, hemos visto en algunos ejemplos las palabras public o private en métodos o atributos.

Los modificadores de acceso nos permite indicar la visibilidad de esos métodos o atributos fuera de la clase, se ponen al principio del método o atributo. Los tipos son:

• public: el método o atributo es accesible por cualquiera.
• private: el método o atributo solo es accesible para la propia clase. Fuera de la clase, no se ven. Se suelen usar en atributos y métodos que solo se usen dentro de la clase.
• protected: el método o atributo de una clase padre se podrá acceder desde las clases hijas de la misma, es muy usado en herencia.
• friendly: este termino, en realidad, en Java no existe, por lo que se declara no poniendo ningún modificador de acceso. El método o atributo solo puede ser visualizado por otras clases que estén dentro del mismo paquete que la clase donde está declarado.

Veamos un ejemplo practico:

/**
 * Clase Empleado
 *
 * Contiene informacion de cada empleado
 *
 * @author Fernando
 * @version 1.0
 */
public class Empleado {
    
    //Atributos
    
    /**
     * Nombre del empleado
     */
    private String nombre;
    
    /**
     * Apellido del empleado
     */
    private String apellido;
    
    /**
     * Edad del empleado
     */
    public int edad;
    
    /**
     * Salario del empleado
     */
    private double salario;
    
    //Metodos
    
    /**
     * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
     * @param sueldoPlus
     * @return true: se suma el plus al sueld
     *         false: no se suma el plus al sueldo
    */
    
    public boolean plus (double sueldoPlus){
        
        boolean aumento=false;
    
        if (edad>40 && compruebaNombre()){
            salario+=sueldoPlus;
            aumento=true;
        }
        
        return aumento;
    }
    
    /**
     * Comprueba que el nombre no este vacio
     * @return true: el nombre es una cadena vacia
     *         false: el nombre no es una cadena vacia
     */
    private boolean compruebaNombre(){
        if(nombre.equals("")){
                return false;
        }

        return true;
    } 

    //Constructores
    
    /**
     * Constructor por defecto
     */
    
    public Empleado(){
        this.nombre="";
        this.apellido="";
        this.edad=0;
        this.salario=0;
    }
    
    /**
     * Constructor con 4 parametros
     * @param nombre nombre del empleado
     * @param apellido nombre del empleado
     * @param edad edad del empleado
     * @param salario salario del empleado
     */
    public Empleado(String nombre, String apellido, int edad, double salario){
        this.nombre=nombre;
        this.apellido=apellido;
        this.edad=edad;
        this.salario=salario;
    }
}

Vemos que hemos puesto el atributo edad como public y un método publico y otro privado. Lo privado no se vera cuando creemos el objeto y lo publico lo podremos invocar. Veamos un ejemplo:

Clase ejecutable

public class EmpleadoApp {

    public static void main(String[] args) {
        
        Empleado empleado1=new Empleado ("Fernando", "Ureña", 23, 800);
        
        //Devolvera false, ya que 23 no es mayor que 40
        System.out.println(empleado1.plus(30));

        //Podemos acceder al atributo edad
        empleado1.edad+=20;

        //Devolvera true, ya que ahora la edad es igual a 43, haciendo que aumente el salario 30 € mas
        System.out.println(empleado1.plus(30));

        //Nos saltara un error, ya que el metodo es privado
        empleado1.compruebaNombre();

        //Creamos un nuevo objeto con el nombre vacio
        Empleado empleado2=new Empleado ("", "Lopez", 50, 1800);

        //Devolvera false, ya que aunque la edad supere los 40 con el metodo privado definido, no nos permitira realizarlo
        System.out.println(empleado2.plus(60));
        
        //Nos saltara un error, ya que nombre no es accesible, es un atributo privado
        empleado2.nombre="Fernando";
    }
}

Lo mas normal es que los atributos sean privados (lo anterior ha sido un ejemplo) para que no sean modificados directamente desde fuera, ademas se suelen usar los métodos get and set para modificar y mostrar el valor de atributos.

EL modificador de acceso protected lo veremos con mas profundidad cuando veamos la herencia en Java.

Espero que os sea de ayuda. Si teneis dudas, preguntad. Estamos para ayudarte.