Modificadores de acceso en Java: public, private, protected, default

Quién puede tocar tu código

Un modificador de acceso es una palabra clave delante de una clase, campo, método o constructor que decide quién más tiene permiso para usarlo. Es la base del encapsulamiento: ocultas las entrañas desordenadas de una clase y expones solo las partes que confías que otro código llame.

Java tiene cuatro niveles, del más abierto al más cerrado: public, protected, default (sin palabra clave en absoluto) y private. Acierta con ellos y una clase se vuelve segura de modificar después, porque nada externo depende de detalles que nunca prometiste mantener.

private: visible solo dentro de la clase

private es el nivel más estricto. Un miembro private solo puede ser tocado por código escrito dentro de la misma clase: ni subclases, ni otras clases del mismo paquete, nadie. Aquí es donde pertenecen la mayoría de tus campos.

public class Main {
    static class BankAccount {
        private double balance = 0;

        public void deposit(double amount) {
            if (amount > 0) {
                balance += amount;
            }
        }

        public double getBalance() {
            return balance;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(100);
        account.deposit(-50); // ignorado por la comprobación dentro de deposit
        System.out.println(account.getBalance());
    }
}

balance es private, así que la única forma de cambiarlo es a través de deposit, que rechaza los importes negativos. Si balance fuera public, cualquier código podría escribir account.balance = -9999 y saltarse la comprobación por completo. Esa protección es el sentido entero de ocultar el campo.

Prueba a descomentar account.balance = 500; en main y obtendrás un error de compilación: balance has private access in BankAccount.

public: visible en todas partes

public es el extremo opuesto: cualquiera, en cualquier lugar, puede usar el miembro. Los nombres de tus métodos que otro código está destinado a llamar suelen ser public. También lo es la propia clase cuando necesita ser alcanzable desde otros paquetes.

public class Main {
    static class Greeter {
        public String greet(String name) {
            return "Hello, " + name + "!";
        }
    }

    public static void main(String[] args) {
        Greeter g = new Greeter();
        System.out.println(g.greet("Ada"));
    }
}

El patrón habitual - a veces llamado la API pública de una clase - es campos privados, métodos públicos. Los campos guardan estado que nadie más debería tocar; los métodos son las puertas controladas de entrada y salida. getBalance y deposit de arriba son exactamente esto.

default (package-private): sin palabra clave en absoluto

Si no escribes ningún modificador, obtienes acceso default, también llamado package-private. El miembro es visible para todas las clases del mismo paquete e invisible para todo lo de fuera. No hay palabra clave para este nivel: la ausencia de una es el nivel.

class Invoice {       // sin modificador -> visible solo dentro de este paquete
    int amount;       // sin modificador -> campo package-private
}

Esto atrapa a muchos principiantes: omitir public no hace que algo sea private, lo hace package-private. Un campo que querías mantener en secreto sigue siendo totalmente legible y escribible por cualquier clase que resulte vivir en el mismo paquete. Si quieres que esté realmente oculto, debes escribir private explícitamente.

El acceso default es genuinamente útil para clases auxiliares que son un detalle de implementación de un paquete: no las exportas, pero las clases que cooperan dentro del paquete pueden seguir usándolas libremente.

protected: paquete más subclases

protected es un escalón más laxo que default. Un miembro protected es visible en todas partes donde lo es default (el mismo paquete), y también para las subclases, incluso subclases en un paquete diferente. Está diseñado para cosas que quieres compartir con las clases que extienden la tuya, pero no con todo el mundo.

public class Main {
    static class Animal {
        protected String name;

        Animal(String name) {
            this.name = name;
        }

        protected String sound() {
            return "...";
        }
    }

    static class Dog extends Animal {
        Dog(String name) {
            super(name);
        }

        // La subclase puede leer el campo protected y llamar al método protected.
        public String describe() {
            return name + " says " + sound();
        }

        @Override
        protected String sound() {
            return "Woof";
        }
    }

    public static void main(String[] args) {
        System.out.println(new Dog("Rex").describe());
    }
}

Dog accede a name y sound() porque son protected y Dog es una subclase. El código externo que no es una subclase y no está en el paquete sigue sin poder tocarlos. Recurre a protected cuando estés diseñando una clase pensada para ser extendida; de lo contrario, prefiere private.

Los cuatro niveles de un vistazo

Aquí está el panorama completo, del más restrictivo al más abierto:

Modificador	Misma clase	Mismo paquete	Subclase (otro paquete)	En todas partes
private	sí	no	no	no
default	sí	sí	no	no
protected	sí	sí	sí	no
public	sí	sí	sí	sí

Una regla práctica sencilla: empieza con private y solo afloja cuando algo realmente necesite un acceso más amplio. Es mucho más fácil ampliar el acceso después que restringirlo una vez que otro código ha empezado a depender de un miembro.

Modificadores en las propias clases

Los modificadores de acceso se aplican también a las clases, no solo a los miembros, pero una clase de nivel superior (una no anidada dentro de otra) solo puede ser public o default. No puedes escribir una clase de nivel superior private o protected.

public class Order { ... }   // alcanzable desde cualquier paquete
class LineItem { ... }       // default - solo este paquete puede verla

Una clase de nivel superior public debe vivir en un archivo con su nombre (Order.java). Las clases anidadas, en cambio, pueden usar los cuatro modificadores, razón por la cual los ejemplos de arriba podían marcar las clases internas como private o default. Un punto sutil: un método public que devuelve un tipo package-private no es muy útil para los llamadores externos, así que mantén tu superficie pública coherente.

Siguiente: miembros estáticos

Hasta ahora cada campo y método aquí pertenece a una instancia: creas un objeto con new y luego llamas a métodos sobre él. Pero a veces un valor o comportamiento pertenece a la clase en su conjunto, compartido entre todas las instancias, como un contador de cuántos objetos existen. Para eso sirve la palabra clave static, y es lo que viene a continuación.