Public, protected, private y package-private en Java: análisis completo

¿Qué ocultan los modificadores de acceso en Java? Inmersión en la encapsulación

Cualquiera que haya empezado a estudiar Java se ha encontrado con las misteriosas palabras public, private y protected delante de campos y métodos. Pero, ¿qué significan realmente? ¿Por qué no podemos hacer todo public y vivir tranquilos? ¿Y qué es ese misterioso package-private del que no se habla en la mayoría de los tutoriales?

En este artículo analizaremos la diferencia entre public, protected, package-private y private en Java con ejemplos reales de código. Aprenderás cómo funciona cada modificador, en qué situaciones aplicarlos y por qué la elección correcta del modificador de acceso es una señal de buen pensamiento arquitectónico. ¡Allá vamos!

¿Para qué sirven los modificadores de acceso?

Imagina que estás construyendo una casa. Tienes una puerta de entrada (accesible para todos), una sala de estar (accesible para amigos), una oficina personal (solo para la familia) y una caja fuerte (solo para ti). Los modificadores de acceso en Java funcionan exactamente igual: determinan quién puede «entrar» a tu clase, método o campo.

El objetivo principal es la encapsulación. Ocultamos los detalles internos de implementación de una clase y proporcionamos al exterior solo lo que realmente se necesita. Esto protege los datos de cambios accidentales y simplifica el mantenimiento del código.

Resumen de los cuatro niveles de acceso

En Java existen cuatro niveles de acceso (del más restrictivo al más abierto):

\n
• private — acceso solo dentro de la clase
\n
• package-private (por defecto) — acceso dentro de la clase y el paquete
\n
• protected — clase + paquete + subclases
\n
• public — acceso desde cualquier lugar
\n

Private: «Mío y de nadie más»

El modificador private es el más restrictivo. Un campo o método marcado como private es accesible solo dentro de la misma clase. Ni las subclases ni las clases del mismo paquete pueden acceder a él.

public class BankAccount {\n    private double balance;  // Accesible solo dentro de la clase\n\n    public BankAccount(double initialBalance) {\n        this.balance = initialBalance;\n    }\n\n    public void deposit(double amount) {\n        if (amount > 0) {\n            balance += amount;\n        }\n    }\n\n    // Este método ve el campo private porque está dentro de la clase\n    public double getBalance() {\n        return balance;\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        BankAccount account = new BankAccount(1000);\n        // account.balance = 5000;  // ¡Error de compilación! balance es private\n        System.out.println(account.getBalance());  // Funciona a través del método público\n    }\n}

Cuándo usarlo: para datos internos de la clase que no deben modificarse desde el exterior (por ejemplo, un contador, el estado interno del objeto).

Package-private (default): «El vecino silencioso»

Si no especificas ningún modificador, Java automáticamente establece el acceso como package-private. Esto significa que el campo o método es visible para todas las clases dentro del mismo paquete, pero no fuera de él.

package com.pythonlib.utils;\n\nclass Helper {  // Clase package-private (sin modificador)\n    String secretMessage = "Visible solo dentro del paquete";  // Campo package-private\n\n    void displayMessage() {  // Método package-private\n        System.out.println(secretMessage);\n    }\n}\n\npackage com.pythonlib.app;\n\nimport com.pythonlib.utils.Helper;\n\npublic class App {\n    public static void main(String[] args) {\n        Helper helper = new Helper();\n        // helper.secretMessage = "¡Error!";  // No visible — otro paquete\n        // helper.displayMessage();  // Error de compilación\n    }\n}

Cuándo usarlo: para clases auxiliares