Clases Personalizadas y Encapsulamiento

Introducción

Una clase personalizada en Java es un molde para construir objetos con atributos y comportamientos definidos por ti. Este capítulo te enseña cómo crear tus propias clases y aplicar el principio de encapsulamiento.

¿Qué es una clase personalizada?

Las clases son estructuras que combinan datos (atributos) y funciones (métodos). Permiten modelar entidades del mundo real en código: usuarios, productos, cuentas, etc.

Encapsulamiento

El encapsulamiento es una práctica clave en la programación orientada a objetos. Consiste en proteger los atributos internos de una clase para que solo se pueda acceder a ellos a través de métodos específicos: getters y setters.

• Los atributos se marcan como private.
• Se accede a ellos con métodos públicos como getNombre() o setEdad().
• Esto permite validar datos antes de modificarlos.

// Definición de una clase personalizada
public class Alumno {
  private String nombre;
  private int edad;

  // Constructor
  public Alumno(String nombre, int edad) {
    this.nombre = nombre;
    this.edad = edad;
  }

  // Getter
  public String getNombre() {
    return nombre;
  }

  // Setter con validación
  public void setNombre(String nombre) {
    if (nombre != null && !nombre.isEmpty()) {
      this.nombre = nombre;
    }
  }

  // Getter
  public int getEdad() {
    return edad;
  }

  // Setter con validación
  public void setEdad(int edad) {
    if (edad >= 0) {
      this.edad = edad;
    }
  }

  // Método personalizado
  public void saludar() {
    System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
  }
}

// Uso de la clase Alumno
Alumno a = new Alumno("Ana", 20);
a.saludar();
a.setEdad(25);
System.out.println(a.getEdad());

Buenas prácticas

• Siempre encapsula los atributos (usa private).
• Valida datos en los setters para evitar estados incorrectos.
• Usa constructores para inicializar objetos correctamente.
• Separa la lógica compleja en métodos, no pongas mucho código en main.
• Utiliza nombres claros y descriptivos para métodos y atributos.

Malas prácticas comunes

• Usar atributos public directamente (rompe el encapsulamiento).
• Colocar lógica pesada dentro de getters o setters.
• No validar datos en los setters (puede generar errores lógicos).
• No usar constructor, forzando al programador a inicializar manualmente después.

Ejemplo Práctico

Supón que desarrollas una app para estudiantes. La clase Alumno representa a un estudiante y encapsula su nombre y edad. Se puede saludar e incluso cambiar sus datos solo si son válidos.

Alumno a = new Alumno("Luis", 18);
a.setEdad(-5); // No cambia porque no es válido
a.saludar();   // Hola, soy Luis y tengo 18 años.

Conclusión

Las clases personalizadas te permiten modelar el mundo con tus propias reglas. Encapsular bien tus atributos es una señal de buen diseño. En el próximo capítulo exploraremos cómo organizar múltiples clases en paquetes y cómo se comunican entre sí.