Programación Orientada a Objetos en Java: Validaciones, Fechas y Algoritmos

Implementación de la Clase Paciente en Java

A continuación, se presenta la estructura de la clase Paciente, aplicando principios de encapsulamiento y validaciones en el constructor.

public class Paciente {
    // 1. Atributos (Private para encapsulamiento) [cite: 128]
    private String nombre;
    private String nif;
    private LocalDate fechaNacimiento; // Usa LocalDate, no Date [cite: 256]

    // 2. Constructor con Validaciones (¡Vital!) [cite: 257]
    public Paciente(String nombre, String nif, LocalDate fechaNacimiento) {
        // Validar ANTES de asignar

        // Ejemplo validación NIF con Regex
        if (!nif.matches("[0-9]{8}[A-Z]")) {
            throw new IllegalArgumentException("Formato NIF incorrecto");
        }

        // Ejemplo validación Fecha (que sea pasado)
        if (fechaNacimiento.isAfter(LocalDate.now())) {
            throw new IllegalArgumentException("La fecha debe ser anterior a hoy");
        }

        this.nombre = nombre;
        this.nif = nif;
        this.fechaNacimiento = fechaNacimiento;
    }

    // 3. Getters y Setters (si se piden)
    // ...

    // 4. toString (Formateado) [cite: 264]
    @Override
    public String toString() {
        // No mostrar más de 3 datos por línea según el examen
        return "Nombre: " + nombre + " | NIF: " + nif + "\n" +
               "Nacimiento: " + fechaNacimiento;
    }
}

Validación de Datos con Expresiones Regulares (Regex)

El examen requiere validar formatos específicos (como el NIF o grupos sanguíneos) utilizando el método matches. Estos son los patrones clave basados en la teoría:

• Un dígito: \\d o [0-9]
• Una letra mayúscula: [A-Z]
• Longitud exacta: {n} (ej. {8} para 8 números).
• Opciones (OR): (A|B)
• Uno o más: +
• Cero o más: *

Manejo Moderno de Fechas con java.time.LocalDate

Es fundamental evitar el uso de la antigua clase Date y emplear la API moderna incluida en el temario.

• Importar: import java.time.LocalDate;
• Fecha actual: LocalDate hoy = LocalDate.now();
• Crear fecha específica: LocalDate fecha = LocalDate.of(2000, 12, 31); (Año, Mes, Día).
• Parsear texto a fecha: LocalDate fecha = LocalDate.parse("2023-12-01"); (Formato ISO YYYY-MM-DD).
• Comparar fechas:
  • fecha1.isBefore(fecha2): Verifica si fecha1 es anterior.
  • fecha1.isAfter(fecha2): Verifica si fecha1 es posterior.

Algoritmos Fundamentales: Cálculo de la Media

Este es un ejercicio típico para procesar acumuladores de edades o notas.

double suma = 0;
int cont = 0;
for (int nota : notas) {
    suma += nota; // Acumular
    cont++;
}
double media = suma / cont;

Gestión de Objetos y Control de Excepciones en la Clase Principal

Implementación de la lógica principal con manejo de errores y entrada de datos.

import java.util.Scanner;
import java.time.LocalDate;
// ... otros imports de tu paquete

public class Principal {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1. Crear el Array (Reserva memoria para referencias, no objetos) [cite: 267]
        Paciente[] misPacientes = new Paciente[5];

        // 2. Bucle para rellenar datos
        for (int i = 0; i < misPacientes.length; i++) {
            System.out.println("Introduciendo paciente " + (i + 1));

            // Pedir datos auxiliares
            System.out.print("Nombre: ");
            String nom = sc.nextLine();
            System.out.print("NIF: ");
            String nif = sc.nextLine();
            // ... pedir resto de datos ...

            // 3. Instanciar con control de Excepciones [cite: 268]
            try {
                // Intentamos crear el objeto. Si falla el constructor, salta al catch.
                misPacientes[i] = new Paciente(nom, nif, LocalDate.now()); // Ejemplo

            } catch (IllegalArgumentException e) {
                // Capturamos el error lanzado en el constructor
                System.out.println("Error creando paciente: " + e.getMessage());
                i--; // Truco: Decrementamos i para repetir esta posición del array
            }
        }

        // 4. Mostrar resultados (Bucle for-each para recorrer)
        for (Paciente p : misPacientes) {
            if (p != null) { // Buena práctica verificar null
                System.out.println(p.toString());
            }
        }
    }
}

Métodos Avanzados de Validación

Comprobación de la Letra del DNI

Lógica para validar la integridad del NIF mediante el cálculo del resto.

private boolean comprobarLetraDNI(String nif) {
    // Extraer número (primeros 8 caracteres)
    String numeroStr = nif.substring(0, 8);
    int numero = Integer.parseInt(numeroStr);

    // Extraer letra (último carácter)
    char letraIntroducida = nif.charAt(8);

    // Cadena de letras oficial (Dada en el examen)
    String letras = "TRWAGMYFPDXBNJZSQVHLCKE";

    // Calcular posición: resto de dividir por 23
    int resto = numero % 23;

    // Obtener la letra correcta
    char letraCorrecta = letras.charAt(resto);

    return letraIntroducida == letraCorrecta;
}

Validación de Matrículas

Uso de expresiones regulares para validar formatos de matrículas vehiculares.

public boolean validarMatricula(String matricula) {
    // 1. Validar que no sea null
    if (matricula == null) return false;

    // 2. Pasamos a mayúsculas para asegurar que el regex funcione
    matricula = matricula.toUpperCase();

    // 3. Definimos el patrón: 4 dígitos + (espacio opcional) + 3 letras
    // Nota: En Java las barras invertidas del regex se escapan con otra barra: \\d
    String patron = "\\d{4}\\s?[A-Z]{3}";

    // 4. Comprobamos
    return matricula.matches(patron);
}

Búsqueda de Máximos y Mínimos

Algoritmo estándar para encontrar el mayor o menor valor dentro de una colección de datos.

int maximo = numeros[0];
for (int i = 1; i < numeros.length; i++) {
    if (numeros[i] > maximo) {
        maximo = numeros[i];
    }
}