Encapsulamiento en Java: Mantén tu Código Seguro y Elegante con Lombok

En Java escribía manualmente todos los getters y setters, y no le daba importancia a la visibilidad de los atributos, luego cuando utilicé Intellij comencé a realizarlos automáticamente.
Con el tiempo, aprendí que el encapsulamiento es una pieza clave para tener código seguro y claro. Y más adelante, descubrí que herramientas como Lombok te pueden ayudar a escribir código aún más limpio y profesional, sin repetir tanto.

¿Qué es el encapsulamiento?

El encapsulamiento es el principio que te invita a proteger los detalles internos de tus clases, exponiendo solo lo necesario al exterior.
Imagínate tus datos valiosos en una caja fuerte: solo quien tenga la llave puede acceder o modificar lo que hay dentro.

¿Por qué es tan importante?

• Evita errores accidentales: Nadie puede modificar datos críticos sin tu permiso.
• Control total: Puedes validar los valores antes de que cambien.
• Flexibilidad: Si cambias la implementación interna, el resto del código no se entera.
• Código más limpio: Con Lombok, reduces código repetitivo y te concentras en la lógica de negocio.

Modificadores de acceso en Java

Estos “candados” controlan quién puede ver y modificar los atributos y métodos de una clase.

• private: Solo la propia clase puede acceder.
• public: Cualquier parte del programa puede acceder.
• protected: Acceso desde la clase, subclases y el paquete.
• (Sin modificador, es accesible solo dentro del paquete.)

Ejemplo práctico usando Lombok

Utilicemos el ejemplo de una cuenta bancaria, usando Lombok para que el código sea más limpio y fácil de mantener.

Primero, agrega Lombok a tu proyecto (si usas Maven):

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

Ahora tu clase luce así:

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@ToString
public class CuentaBancaria {
    private double saldo;

    public CuentaBancaria(double saldoInicial) {
        this.saldo = saldoInicial;
    }

    public void depositar(double monto) {
        if (monto > 0) {
            saldo += monto;
        }
    }

    public boolean retirar(double monto) {
        if (monto > 0 && monto <= saldo) {
            saldo -= monto;
            return true;
        }
        return false;
    }
}

• Con @Getter, Lombok genera automáticamente el método getSaldo().
• @ToString te da un método toString() útil para debuggear.
• Puedes agregar @Setter si en algún caso quieres permitir cambiar el valor, pero en este ejemplo solo el saldo se modifica mediante métodos específicos.

Buenas prácticas al encapsular con Lombok

• Haz los atributos private siempre. Así garantizas que nadie los modifica por accidente.
• Genera solo los getters/setters necesarios: Usa @Getter y/o @Setter a nivel de clase o atributo según lo que realmente necesitas exponer.
• Valida siempre: Si un atributo requiere validación antes de ser cambiado, NO uses @Setter, crea tu propio método para tener control total.

import lombok.Getter;

@Getter
public class Persona {
    private String nombre;
    private int edad;

    public void setEdad(int edad) {
        if (edad >= 0) {
            this.edad = edad;
        }
    }

    // Lombok genera solo getNombre() y getEdad()
}

Errores comunes

Diagramas explicativos

Diagrama 1: Caja fuerte y ventanilla

+-----------------------------+
|       CuentaBancaria        |
|-----------------------------|
|  - saldo: double            |   <--- Caja fuerte (privado)
|-----------------------------|
| + getSaldo(): double        |   <--- Ventanilla (getter generado por Lombok)
| + depositar(monto): void    |   <--- Ventanilla (método público)
| + retirar(monto): boolean   |   <--- Ventanilla (método público)
+-----------------------------+

Diagrama 2: Acceso directo vs. acceso controlado

Sin encapsulamiento (public):

+-------------+
| Persona     |
|-------------|
| edad: int   |  <--- Cualquiera puede cambiarlo

Con encapsulamiento (private + Lombok):

+-------------+
| Persona     |
|-------------|
| - edad: int |  <--- Solo la clase accede
|-------------|
| + getEdad() |  <--- Controlado (getter de Lombok)
| + setEdad() |  <--- Si lo escribes manualmente, puedes validar
+-------------+

Conclusión

El encapsulamiento es mucho más que una regla técnica: es una manera de proteger tu código, darle estructura y facilitar la colaboración en equipos, incluso cuando solo eres tú quien desarrolla. Adoptar buenas prácticas desde el inicio —como hacer tus atributos privados, validar los cambios y aprovechar herramientas como Lombok— te permite enfocarte en lo que realmente importa: la lógica y el crecimiento de tus aplicaciones, no en escribir código repetitivo.

Recuerda, la seguridad y claridad que logras con el encapsulamiento no solo te ahorran problemas hoy, sino que preparan tu proyecto para escalar y adaptarse al futuro. No subestimes la importancia de un código bien protegido y, sobre todo, ¡disfruta el picar código!