Código fuente
     ↓
[Análisis Léxico]       → Tokens (palabras reservadas, identificadores, operadores)
     ↓
[Análisis Sintáctico]   → Árbol de Análisis Sintáctico (AST)
     ↓
[Análisis Semántico]    → Comprobación de tipos, tabla de símbolos
     ↓
[Generación de Código Intermedio]   → Código independiente de la máquina
     ↓
[Optimización]          → Mejora eficiencia sin cambiar comportamiento
     ↓
[Generación de Código Máquina]
     ↓
Ejecutable (.exe / binario)

Ejemplo: -5 en 8 bits (complemento a 2)
  5 en binario = 00000101
  Invertir bits = 11111010
  Sumar 1       = 11111011  → Esto es -5

Estructura IEEE 754 (float, 32 bits):
[1 bit signo | 8 bits exponente | 23 bits mantisa]

Valor = (-1)^signo × 1.mantisa × 2^(exponente - 127)

ASCII: 'A' = 65, 'a' = 97, '0' = 48, espacio = 32
Char en C: char c = 'A';   // almacena el valor 65

boolean activo = true;
boolean terminado = false;

// Enum en C
enum DiaSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO };
enum DiaSemana hoy = MIERCOLES;  // hoy vale 2 (empieza en 0)

// Enum en Java (más potente que en C)
enum Estado { PENDIENTE, ACEPTADO, RECHAZADO }
Estado e = Estado.ACEPTADO;

// Puntero en C
int x = 10;
int *ptr = &x;   // ptr apunta a la dirección de x
printf("%d", *ptr);  // imprime 10 (desreferencia)
printf("%p", ptr);   // imprime la dirección de memoria

byte → short → int → long → float → double

int i = 100;
long l = i;   // automático: int → long
double d = i; // automático: int → double

double d = 9.99;
int i = (int) d;  // i = 9 (se trunca la parte decimal, NO se redondea)

long l = 12345678901L;
int j = (int) l;  // pérdida de bits significativos

AND:           OR:            NOT:       XOR:
A  B  A&&B    A  B  A||B    A   !A     A  B  A^B
T  T   T      T  T   T      T    F     T  T   F
T  F   F      T  F   T      F    T     T  F   T
F  T   F      F  T   T                 F  T   T
F  F   F      F  F   F                 F  F   F

int x = 5;
x++;    // Post-incremento: usa x (=5) luego suma 1 → x=6
++x;    // Pre-incremento: suma 1 primero → x=7, usa x (=7)
x--;    // Post-decremento
--x;    // Pre-decremento

1.  ()             → Paréntesis (máxima prioridad)
2.  ! ~ ++ --      → Unarios
3.  * / %          → Multiplicativos
4.  + -            → Aditivos
5.  << >>          → Desplazamiento de bits
6.  < <= > >=      → Relacionales
7.  == !=          → Igualdad
8.  &              → AND bit a bit
9.  ^              → XOR bit a bit
10. |              → OR bit a bit
11. &&             → AND lógico
12. ||             → OR lógico
13. ?:             → Ternario
14. = += -= *= /=  → Asignación (mínima prioridad)

SI condición ENTONCES
    instrucciones
SINO SI condición2 ENTONCES
    instrucciones
SINO
    instrucciones
FIN SI

int nota = 7;

if (nota >= 9) {
    System.out.println("Sobresaliente");
} else if (nota >= 7) {
    System.out.println("Notable");
} else if (nota >= 5) {
    System.out.println("Aprobado");
} else {
    System.out.println("Suspenso");
}
// Salida: Notable

nota = 7
if nota >= 9:
    print("Sobresaliente")
elif nota >= 7:
    print("Notable")
elif nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")

// Java
int dia = 3;
switch (dia) {
    case 1:
        System.out.println("Lunes");
        break;
    case 2:
        System.out.println("Martes");
        break;
    case 3:
        System.out.println("Miércoles");
        break;
    default:
        System.out.println("Otro día");
}
// Salida: Miércoles

SEGÚN variable HACER
    CASO valor1: instrucciones
    CASO valor2: instrucciones
    POR DEFECTO: instrucciones
FIN SEGÚN

String resultado = switch (dia) {
    case 1 -> "Lunes";
    case 2 -> "Martes";
    default -> "Otro";
};

// condicion ? valor_si_true : valor_si_false
int max = (a > b) ? a : b;
String estado = (activo) ? "Activo" : "Inactivo";

// Si (a > 0) es false, NO se evalúa (b / a) → evita división por cero
if (a > 0 && b / a > 2) { ... }

// Si (x != null) es false, NO se evalúa x.length() → evita NullPointerException
if (x != null && x.length() > 0) { ... }

// Java
int i = 0;
while (i < 5) {
    System.out.println("Iteración: " + i);
    i++;
}
// Imprime 0, 1, 2, 3, 4

MIENTRAS condicion HACER
    instrucciones
FIN MIENTRAS

int i = 0;
do {
    System.out.println("Iteración: " + i);
    i++;
} while (i < 5);

HACER
    instrucciones
MIENTRAS condicion

// Java — sintaxis clásica
for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

// For mejorado (for-each) para colecciones/arrays
int[] numeros = {10, 20, 30, 40};
for (int n : numeros) {
    System.out.println(n);
}

# Python
for i in range(5):         # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 10, 2):  # 2, 4, 6, 8
    print(i)

PARA i DESDE 1 HASTA 10 PASO 1 HACER
    instrucciones
FIN PARA

for (int i = 0; i < 10; i++) {
    if (i == 3) continue;  // Salta el 3
    if (i == 7) break;     // Sale del bucle al llegar a 7
    System.out.print(i + " "); // Imprime: 0 1 2 4 5 6
}

n! = n × (n-1) × (n-2) × ... × 1
0! = 1  (caso base)

// Java - Recursivo
int factorial(int n) {
    if (n == 0) return 1;           // Caso base
    return n * factorial(n - 1);    // Caso recursivo
}
// factorial(5) = 5 × 4 × 3 × 2 × 1 = 120

// Java - Iterativo (equivalente)
int factorialIterativo(int n) {
    int resultado = 1;
    for (int i = 1; i <= n; i++) {
        resultado *= i;
    }
    return resultado;
}

F(0) = 0, F(1) = 1
F(n) = F(n-1) + F(n-2)

int fibonacci(int n) {
    if (n <= 1) return n;                       // Casos base
    return fibonacci(n - 1) + fibonacci(n - 2); // Caso recursivo
}
// fibonacci(6) → secuencia: 0,1,1,2,3,5,8 → resultado: 8

factorial(4)
  → 4 * factorial(3)
        → 3 * factorial(2)
              → 2 * factorial(1)
                    → 1 * factorial(0)
                          → 1  (caso base)
                    → 1 * 1 = 1
              → 2 * 1 = 2
        → 3 * 2 = 6
  → 4 * 6 = 24

// Procedimiento (no devuelve nada)
void mostrarBienvenida(String nombre) {
    System.out.println("Bienvenido, " + nombre + "!");
}

// Función (devuelve un valor)
int sumar(int a, int b) {
    return a + b;
}

// Uso
mostrarBienvenida("Ana");       // Llama al procedimiento
int resultado = sumar(3, 5);    // Llama a la función → resultado = 8

void duplicar(int x) {
    x = x * 2;     // Solo modifica la copia local
    System.out.println("Dentro: " + x); // 10
}

int num = 5;
duplicar(num);
System.out.println("Fuera: " + num); // Sigue siendo 5

// En C, se simula con punteros
void duplicar(int *x) {
    *x = *x * 2;   // Modifica el valor en la dirección apuntada
}

int num = 5;
duplicar(&num);
printf("%d", num);  // num ahora es 10

// En Java: los objetos se pasan por referencia de valor
// (se pasa la referencia, no el objeto completo)
void modificar(int[] arr) {
    arr[0] = 99;  // Sí modifica el array original
}

int global = 100;  // Variable global

void ejemplo() {
    int local = 50;         // Variable local
    System.out.println(global); // OK: accede a la global
    System.out.println(local);  // OK: accede a la local
}
// Aquí NO se puede acceder a 'local'

Pila de llamadas para factorial(3):
┌─────────────────┐
│ factorial(0)=1  │  ← cima (último en entrar)
├─────────────────┤
│ factorial(1)=1  │
├─────────────────┤
│ factorial(2)=2  │
├─────────────────┤
│ factorial(3)=6  │  ← base
└─────────────────┘

int sumar(int a, int b) { return a + b; }
double sumar(double a, double b) { return a + b; }
int sumar(int a, int b, int c) { return a + b + c; }

sumar(1, 2);        // llama a la primera
sumar(1.5, 2.5);    // llama a la segunda
sumar(1, 2, 3);     // llama a la tercera

// Java
int[] notas = new int[5];          // Vector de 5 enteros (sin inicializar → todos 0)
int[] pares = {2, 4, 6, 8, 10};   // Con inicialización directa

pares[0] = 2;   // Primer elemento
pares[4] = 10;  // Último elemento
// pares[5] → ArrayIndexOutOfBoundsException (fuera de rango)

// C
int notas[5];                    // Declara 5 enteros
int pares[] = {2, 4, 6, 8, 10}; // Con inicialización
notas[0] = 7;                    // Acceso

# Python (listas dinámicas)
notas = [0] * 5            # Lista de 5 ceros
pares = [2, 4, 6, 8, 10]
print(pares[2])            # 6

int[] v = {5, 3, 8, 1, 9};

// Recorrido con for clásico
for (int i = 0; i < v.length; i++) {
    System.out.print(v[i] + " "); // 5 3 8 1 9
}

// Recorrido con for-each
for (int elem : v) {
    System.out.print(elem + " ");
}

// Búsqueda lineal: O(n) — no requiere ordenación
int buscarLineal(int[] v, int objetivo) {
    for (int i = 0; i < v.length; i++) {
        if (v[i] == objetivo) return i;  // Devuelve el índice
    }
    return -1;  // No encontrado
}

// Búsqueda binaria (el vector DEBE estar ORDENADO): O(log n)
int buscarBinaria(int[] v, int objetivo) {
    int izq = 0, der = v.length - 1;
    while (izq <= der) {
        int medio = (izq + der) / 2;
        if (v[medio] == objetivo) return medio;
        else if (v[medio] < objetivo) izq = medio + 1;
        else der = medio - 1;
    }
    return -1;
}

void burbuja(int[] v) {
    int n = v.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (v[j] > v[j + 1]) {
                // Intercambio
                int temp = v[j];
                v[j] = v[j + 1];
                v[j + 1] = temp;
            }
        }
    }
}

// Matriz 3×3 en Java
int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Acceso: matriz[fila][columna]
System.out.println(matriz[1][2]);  // 6 (fila 1, columna 2)

// Recorrido
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.print(matriz[i][j] + " ");
    }
    System.out.println();
}

// Definición del tipo registro
struct Alumno {
    char nombre[50];
    int edad;
    float nota;
};

// Uso
struct Alumno a1;
strcpy(a1.nombre, "María García");
a1.edad = 22;
a1.nota = 8.5;

// Acceso a campos con el operador punto (.)
printf("Nombre: %s\n", a1.nombre);
printf("Nota: %.1f\n", a1.nota);

TYPE
  TAlumno = RECORD
    nombre : STRING[50];
    edad   : INTEGER;
    nota   : REAL;
  END;

VAR
  alumno1 : TAlumno;

BEGIN
  alumno1.nombre := 'María';
  alumno1.edad   := 22;
  alumno1.nota   := 8.5;
END.

class Alumno {
    String nombre;
    int edad;
    double nota;
}

Alumno a = new Alumno();
a.nombre = "María García";
a.edad = 22;
a.nota = 8.5;

struct Alumno clase[30];  // Array de 30 alumnos

// Inicializar el primero
strcpy(clase[0].nombre, "Ana López");
clase[0].edad = 20;
clase[0].nota = 7.5;

// Recorrer y mostrar todos
for (int i = 0; i < 30; i++) {
    printf("%s - %d años - %.1f\n",
        clase[i].nombre, clase[i].edad, clase[i].nota);
}

┌─────────────────────────────┐
│       CABECERA              │  Nombre, metadatos, imports, includes
├─────────────────────────────┤
│    DECLARACIONES GLOBALES   │  Constantes, tipos, variables globales
├─────────────────────────────┤
│    SUBPROGRAMAS             │  Funciones y procedimientos
├─────────────────────────────┤
│    PROGRAMA PRINCIPAL       │  Punto de entrada (main)
└─────────────────────────────┘

PROGRAMA nombre_del_programa

CONSTANTES
    PI = 3.14159
    MAX = 100

TIPOS
    TAlumno = REGISTRO
        nombre: CADENA
        nota: REAL
    FIN REGISTRO

VARIABLES
    edad: ENTERO
    nombre: CADENA

FUNCIÓN calcularArea(radio: REAL): REAL
INICIO
    DEVOLVER PI * radio * radio
FIN FUNCIÓN

PROCEDIMIENTO mostrar(texto: CADENA)
INICIO
    ESCRIBIR(texto)
FIN PROCEDIMIENTO

INICIO   // Programa principal
    nombre ← "Ana"
    edad ← 25
    mostrar("Hola, " + nombre)
    ESCRIBIR(calcularArea(5.0))
FIN

/* ====== Cabecera ====== */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ====== Constantes ====== */
#define MAX 100
#define PI 3.14159

/* ====== Tipos definidos por el usuario ====== */
typedef struct {
    char nombre[50];
    int edad;
    float nota;
} Alumno;

/* ====== Variables globales ====== */
int contador = 0;

/* ====== Declaración de funciones ====== */
float calcularMedia(float notas[], int n);
void mostrarAlumno(Alumno a);

/* ====== Función principal ====== */
int main() {
    float notas[] = {7.5, 8.0, 6.5, 9.0};
    Alumno a1;

    strcpy(a1.nombre, "Carlos Ruiz");
    a1.edad = 21;
    a1.nota = calcularMedia(notas, 4);

    mostrarAlumno(a1);

    return 0;  // 0 indica ejecución exitosa
}

/* ====== Implementación de funciones ====== */
float calcularMedia(float notas[], int n) {
    float suma = 0;
    for (int i = 0; i < n; i++) suma += notas[i];
    return suma / n;
}

void mostrarAlumno(Alumno a) {
    printf("Nombre: %s\nEdad: %d\nNota: %.2f\n",
           a.nombre, a.edad, a.nota);
}

/* ====== Paquete e imports ====== */
package com.ejemplo;

import java.util.Scanner;

/* ====== Clase principal ====== */
public class GestionAlumnos {

    /* ====== Constantes de clase ====== */
    static final int MAX_ALUMNOS = 30;

    /* ====== Atributos de clase ====== */
    static int totalAlumnos = 0;

    /* ====== Método principal ====== */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Introduce una nota: ");
        double nota = sc.nextDouble();

        String calificacion = obtenerCalificacion(nota);
        System.out.println("Calificación: " + calificacion);

        sc.close();
    }

    /* ====== Métodos auxiliares ====== */
    static String obtenerCalificacion(double nota) {
        if (nota >= 9) return "Sobresaliente";
        else if (nota >= 7) return "Notable";
        else if (nota >= 5) return "Aprobado";
        else return "Suspenso";
    }

    static double calcularMedia(double[] notas) {
        double suma = 0;
        for (double n : notas) suma += n;
        return suma / notas.length;
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Módulo de gestión de alumnos
"""

# ====== Imports ======
import sys

# ====== Constantes ======
MAX_ALUMNOS = 30
PI = 3.14159

# ====== Funciones ======
def calcular_media(notas: list) -> float:
    """Calcula la media de una lista de notas."""
    if not notas:
        return 0.0
    return sum(notas) / len(notas)

def obtener_calificacion(nota: float) -> str:
    """Devuelve la calificación textual de una nota."""
    if nota >= 9:
        return "Sobresaliente"
    elif nota >= 7:
        return "Notable"
    elif nota >= 5:
        return "Aprobado"
    else:
        return "Suspenso"

# ====== Programa principal ======
def main():
    notas = [7.5, 8.0, 9.5, 6.0, 5.5]
    media = calcular_media(notas)
    calificacion = obtener_calificacion(media)

    print(f"Media: {media:.2f}")
    print(f"Calificación: {calificacion}")

if __name__ == "__main__":
    main()

1. ESCRITURA      → El programador escribe el código fuente (.c, .java, .py)
2. COMPILACIÓN    → El compilador traduce a código objeto / bytecode
3. ENLAZADO       → El linker une código objeto con bibliotecas → ejecutable
4. CARGA          → El SO carga el ejecutable en memoria RAM
5. EJECUCIÓN      → La CPU ejecuta las instrucciones
6. FINALIZACIÓN   → El programa libera recursos y devuelve el control al SO

┌──────────────────────────────┐  Dirección alta
│          PILA (Stack)        │  Variables locales, marcos de función
│      (crece hacia abajo)     │
├──────────────────────────────┤
│                              │
│          MONTÓN (Heap)       │  Memoria dinámica (new, malloc)
│       (crece hacia arriba)   │
│                              │
├──────────────────────────────┤
│   SEGMENTO DE DATOS (.data)  │  Variables globales y estáticas
├──────────────────────────────┤
│   SEGMENTO DE CÓDIGO (.text) │  Instrucciones del programa
└──────────────────────────────┘  Dirección baja

// Clase padre (superclase)
public class Persona {
    protected String dni;
    protected String nrp;
    protected String nombre;
    protected String apellidos;

    public Persona(String dni, String nrp, String nombre, String apellidos) {
        this.dni = dni;
        this.nrp = nrp;
        this.nombre = nombre;
        this.apellidos = apellidos;
    }

    public String getDni()       { return dni; }
    public String getNrp()       { return nrp; }
    public String getNombre()    { return nombre; }
    public String getApellidos() { return apellidos; }

    @Override
    public String toString() {
        return nombre + " " + apellidos + " (DNI: " + dni + ")";
    }
}

// Clase hija que hereda de Persona
public class Trabajador extends Persona {
    private String categoria;
    private String centro;
    private String mesa;

    public Trabajador(String dni, String nrp, String nombre,
                      String apellidos, String categoria, String centro) {
        super(dni, nrp, nombre, apellidos); // Llama al constructor del padre
        this.categoria = categoria;
        this.centro = centro;
    }

    public String getCategoria() { return categoria; }
    public String getCentro()    { return centro; }
    public String getMesa()      { return mesa; }
    public void setMesa(String mesa) { this.mesa = mesa; }
}

import java.time.LocalDate;

// Gestiona toda la información de votación de un trabajador
public class GestorVotoPorCorreo {

    private String dni;
    private LocalDate fechaSolicitud;
    private String estadoSolicitud; // "espera", "aceptado", "rechazado"
    private LocalDate fechaRecepcion;
    private LocalDate fechaEntrega;
    private String mesaEntrega;

    public GestorVotoPorCorreo(String dni) {
        this.dni = dni;
    }

    // a) ¿Ha solicitado el voto por correo?
    public boolean haSolicitadoVotoPorCorreo() {
        return fechaSolicitud != null;
    }

    // b) ¿Se le ha concedido el voto por correo?
    public boolean leConcedieronVotoPorCorreo() {
        return "aceptado".equalsIgnoreCase(estadoSolicitud);
    }

    // c) ¿Ha sido recibido el voto por correo?
    public boolean fueRecibidoElVoto() {
        return fechaRecepcion != null;
    }

    // d) ¿Se ha entregado el voto a la mesa?
    public boolean fueEntregadoALaMesa() {
        return fechaEntrega != null && mesaEntrega != null;
    }

    // Setters
    public void registrarSolicitud(LocalDate fecha) {
        this.fechaSolicitud = fecha;
        this.estadoSolicitud = "espera";
    }
    public void actualizarEstado(String estado) {
        this.estadoSolicitud = estado;
    }
    public void registrarRecepcion(LocalDate fecha) {
        this.fechaRecepcion = fecha;
    }
    public void registrarEntrega(String mesa, LocalDate fecha) {
        this.mesaEntrega = mesa;
        this.fechaEntrega = fecha;
    }
}

public class AplicacionVoto {
    public static void main(String[] args) {

        GestorVotoPorCorreo gestor = new GestorVotoPorCorreo("12345678A");

        // Simulamos el proceso completo
        gestor.registrarSolicitud(LocalDate.of(2024, 5, 10));
        gestor.actualizarEstado("aceptado");
        gestor.registrarRecepcion(LocalDate.of(2024, 6, 1));
        gestor.registrarEntrega("Mesa 3 - Centro Norte", LocalDate.of(2024, 6, 5));

        // Consultas
        System.out.println("¿Ha solicitado voto por correo? " +
            gestor.haSolicitadoVotoPorCorreo());

        System.out.println("¿Le fue concedido el voto? " +
            gestor.leConcedieronVotoPorCorreo());

        System.out.println("¿Fue recibido el voto? " +
            gestor.fueRecibidoElVoto());

        System.out.println("¿Fue entregado a la mesa? " +
            gestor.fueEntregadoALaMesa());
    }
}

Persona (DNI, NRP, Nombre, Apellidos)
DatosLaborales (NRP, Categoria, Centro)
DatosVotacion (NRP, Mesa, Centro)
SolicitudesVotoPorCorreo (DNI, Fecha, Estado)
RecibidosVotosPorCorreo (DNI, Fecha)
EntregadosVotosPorCorreo (DNI, Mesa, Fecha)

-- AMPLIACIÓN PARA ESCRUTINIO --
Urna (ID_Urna, Mesa, Categoria, VotosCandidata1, VotosCandidata2, VotosBlanco, VotosNulo)
Mesa (ID_Mesa, Centro, NumUrnas)
ResultadoEscrutinio (ID_Mesa, VotosPonderados, FechaCalculo)

public class Urna {
    private String idUrna;
    private String mesa;
    private String categoria;
    private int votosTotal;

    // Mapa de ponderaciones por categoría
    private static final Map<String, Double> PONDERACIONES = new HashMap<>();
    static {
        PONDERACIONES.put("PDI_PERMANENTE", 0.51);
        PONDERACIONES.put("RESTO_PROFESORADO", 0.16);
        PONDERACIONES.put("ESTUDIANTES", 0.24);
        PONDERACIONES.put("PAS", 0.09);
    }

    public double calcularVotosPonderados() {
        double ponderacion = PONDERACIONES.getOrDefault(categoria, 0.0);
        return votosTotal * ponderacion;
    }

    // Getters y setters...
}

public class Mesa {
    private String idMesa;
    private List<Urna> urnas = new ArrayList<>();

    public void agregarUrna(Urna urna) {
        urnas.add(urna);
    }

    public double calcularResultadoPonderado() {
        return urnas.stream()
                    .mapToDouble(Urna::calcularVotosPonderados)
                    .sum();
    }
}

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <!-- Información de autenticación, seguridad, etc. -->
  </soap:Header>
  <soap:Body>
    <ObtenerPersona>
      <dni>12345678A</dni>
    </ObtenerPersona>
  </soap:Body>
</soap:Envelope>

GET    /api/trabajadores/{nrp}/centromesa
POST   /api/trabajadores/{nrp}/centromesa
GET    /api/votoporcorreo/{dni}
PUT    /api/votoporcorreo/{dni}/estado

@RestController
@RequestMapping("/api")
public class VotacionController {

    // Asignar centro y mesa a un trabajador
    @PostMapping("/trabajadores/{nrp}/centromesa")
    public ResponseEntity<String> asignarCentroYMesa(
            @PathVariable String nrp,
            @RequestBody DatosVotacionDTO datos) {
        // Lógica de negocio: actualizar DatosVotacion en BD
        datosVotacionService.asignar(nrp, datos.getMesa(), datos.getCentro());
        return ResponseEntity.ok("Centro y mesa asignados correctamente");
    }

    // Saber si una persona ha pedido el voto por correo
    @GetMapping("/votoporcorreo/{dni}")
    public ResponseEntity<SolicitudDTO> consultarSolicitud(
            @PathVariable String dni) {
        SolicitudDTO solicitud = solicitudService.findByDni(dni);
        if (solicitud == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(solicitud);
    }

    // Actualizar el estado de la petición del voto por correo
    @PutMapping("/votoporcorreo/{dni}/estado")
    public ResponseEntity<String> actualizarEstado(
            @PathVariable String dni,
            @RequestBody EstadoDTO estadoDTO) {
        solicitudService.actualizarEstado(dni, estadoDTO.getEstado());
        return ResponseEntity.ok("Estado actualizado a: " + estadoDTO.getEstado());
    }
}

{
  "trabajador": {
    "datosPersonales": {
      "dni": "12345678A",
      "nrp": "NRP001",
      "nombre": "María",
      "apellidos": "García López"
    },
    "datosLaborales": {
      "categoria": "PDI_PERMANENTE",
      "centro": "Facultad de Informática"
    },
    "datosVotacion": {
      "mesa": "Mesa 3",
      "centro": "Edificio Central"
    },
    "votoPorCorreo": {
      "solicitud": {
        "fecha": "2024-05-10",
        "estado": "aceptado"
      },
      "recepcion": {
        "fecha": "2024-06-01"
      },
      "entrega": {
        "mesa": "Mesa 3",
        "fecha": "2024-06-05"
      }
    }
  }
}

public class TrabajadorDTO {
    private DatosPersonalesDTO datosPersonales;
    private DatosLaboralesDTO datosLaborales;
    private DatosVotacionDTO datosVotacion;
    private VotoPorCorreoDTO votoPorCorreo;

    // Clases internas
    public static class DatosPersonalesDTO {
        private String dni;
        private String nrp;
        private String nombre;
        private String apellidos;
        // getters y setters
    }

    public static class DatosLaboralesDTO {
        private String categoria;
        private String centro;
        // getters y setters
    }

    public static class DatosVotacionDTO {
        private String mesa;
        private String centro;
        // getters y setters
    }

    public static class VotoPorCorreoDTO {
        private SolicitudDTO solicitud;
        private RecepcionDTO recepcion;
        private EntregaDTO entrega;
        // getters y setters
    }
    // getters y setters generales
}

import javax.persistence.*;

@Entity                           // (1)
@Table(name = "Persona")          // (2)
public class Persona {
    @Id                           // (3)
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // (4)
    private Long id;

    @Column(name = "DNI")         // (5)
    private String dni;

    @Column(name = "NRP")
    private String nrp;

    @Column(name = "Nombre")
    private String nombre;

    @Column(name = "Apellidos")
    private String apellidos;
}

<?php
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="Persona")
 */
class Persona
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(name="DNI", type="string", length=9)
     */
    private $dni;

    /**
     * @ORM\Column(name="NRP", type="string")
     */
    private $nrp;

    /**
     * @ORM\Column(name="Nombre", type="string")
     */
    private $nombre;

    /**
     * @ORM\Column(name="Apellidos", type="string")
     */
    private $apellidos;
}

public interface Votable {
    boolean haSolicitadoVoto();
    boolean haEntregadoVoto();
}

public class Trabajador extends Persona implements Votable {
    @Override
    public boolean haSolicitadoVoto() { /* implementación */ }
    @Override
    public boolean haEntregadoVoto()  { /* implementación */ }
}

public abstract class EntidadBase {
    protected Long id;

    // Método abstracto: las subclases DEBEN implementarlo
    public abstract String getIdentificador();

    // Método concreto: las subclases PUEDEN sobreescribirlo
    public Long getId() { return id; }
}

try {
    int resultado = 10 / 0;   // Lanza ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
} catch (Exception e) {
    System.out.println("Error genérico: " + e.getMessage());
} finally {
    System.out.println("Este bloque siempre se ejecuta");
}

Throwable
├── Error (errores graves del sistema: OutOfMemoryError, StackOverflowError)
└── Exception
    ├── RuntimeException (no comprobadas: NullPointerException, ArrayIndexOutOfBoundsException)
    └── IOException, SQLException... (comprobadas: deben capturarse o declararse)