Herramientas para Estudiantes

                        /**
 * Encapsulamiento: Ocultar implementación interna
 * Atributos privados + métodos públicos de acceso
 */
public class Empleado {
    // Atributos privados - no accesibles directamente
    private String rut;
    private String nombre;
    private double salario;
    private boolean activo;

    // Constructor con validación
    public Empleado(String rut, String nombre, double salario) {
        this.setRut(rut);      // Usa setter para validar
        this.nombre = nombre;
        this.setSalario(salario);
        this.activo = true;
    }

    // Getter - acceso controlado de lectura
    public String getRut() {
        return this.rut;
    }

    // Setter con validación - control de escritura
    public void setRut(String rut) {
        if (rut == null || rut.length() < 8) {
            throw new IllegalArgumentException("RUT inválido");
        }
        this.rut = rut;
    }

    public double getSalario() {
        return this.salario;
    }

    public void setSalario(double salario) {
        if (salario < 0) {
            throw new IllegalArgumentException("Salario no puede ser negativo");
        }
        this.salario = salario;
    }

    // Método de negocio encapsulado
    public double calcularSalarioAnual() {
        return this.salario * 12 + (this.salario * 0.5); // + aguinaldo
    }
}
                      

                        /**
 * Herencia: Crear jerarquías de clases
 * Clase hija hereda atributos y métodos de la padre
 */

// Clase padre (superclase)
public class Persona {
    protected String nombre;
    protected String email;
    protected LocalDate fechaNacimiento;

    public Persona(String nombre, String email) {
        this.nombre = nombre;
        this.email = email;
    }

    public String presentarse() {
        return "Hola, soy " + this.nombre;
    }

    public int calcularEdad() {
        return Period.between(fechaNacimiento, LocalDate.now()).getYears();
    }
}

// Clase hija (subclase) - hereda de Persona
public class Estudiante extends Persona {
    private String matricula;
    private String carrera;
    private List<String> asignaturas;

    // Constructor llama a super() para inicializar padre
    public Estudiante(String nombre, String email, String matricula, String carrera) {
        super(nombre, email);  // Llama constructor padre
        this.matricula = matricula;
        this.carrera = carrera;
        this.asignaturas = new ArrayList<>();
    }

    // Método propio de Estudiante
    public void inscribirAsignatura(String asignatura) {
        this.asignaturas.add(asignatura);
    }

    // Sobrescribir método padre
    @Override
    public String presentarse() {
        return super.presentarse() + " y estudio " + this.carrera;
    }
}
                      

                        /**
 * Polimorfismo: "Muchas formas"
 * - Sobrecarga: mismo nombre, diferentes parámetros
 * - Sobrescritura: @Override en clases hijas
 */

// Clase abstracta base
public abstract class Vehiculo {
    protected String marca;
    protected String modelo;

    public Vehiculo(String marca, String modelo) {
        this.marca = marca;
        this.modelo = modelo;
    }

    // Método abstracto - cada vehículo lo implementa diferente
    public abstract void acelerar();

    // Método concreto heredable
    public String getInfo() {
        return marca + " " + modelo;
    }
}

// Polimorfismo por sobrescritura
public class Auto extends Vehiculo {
    private int numeroPuertas;

    public Auto(String marca, String modelo, int puertas) {
        super(marca, modelo);
        this.numeroPuertas = puertas;
    }

    @Override
    public void acelerar() {
        System.out.println("El auto acelera con el pedal");
    }
}

public class Moto extends Vehiculo {
    private int cilindrada;

    public Moto(String marca, String modelo, int cc) {
        super(marca, modelo);
        this.cilindrada = cc;
    }

    @Override
    public void acelerar() {
        System.out.println("La moto acelera con el puño");
    }
}

// Uso del polimorfismo
public class Main {
    public static void main(String[] args) {
        // Una variable del tipo padre puede referenciar hijos
        List<Vehiculo> vehiculos = new ArrayList<>();
        vehiculos.add(new Auto("Toyota", "Corolla", 4));
        vehiculos.add(new Moto("Honda", "CBR", 600));

        // Cada uno ejecuta SU versión de acelerar()
        for (Vehiculo v : vehiculos) {
            v.acelerar();  // Polimorfismo en acción
        }
    }
}
                      

                        /**
 * Abstracción: Ocultar complejidad, mostrar solo lo esencial
 * Interface = contrato que las clases deben cumplir
 */

// Interface define QUÉ hacer, no CÓMO
public interface Registrable {
    String obtenerIdentificador();
    LocalDateTime getFechaRegistro();
    boolean validar();
}

// Interface para persistencia
public interface Persistible {
    void guardar();
    void eliminar();
    void actualizar();
}

// Clase implementa múltiples interfaces
public class Producto implements Registrable, Persistible {
    private String codigo;
    private String nombre;
    private double precio;
    private LocalDateTime fechaCreacion;

    public Producto(String codigo, String nombre, double precio) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
        this.fechaCreacion = LocalDateTime.now();
    }

    // Implementación de Registrable
    @Override
    public String obtenerIdentificador() {
        return this.codigo;
    }

    @Override
    public LocalDateTime getFechaRegistro() {
        return this.fechaCreacion;
    }

    @Override
    public boolean validar() {
        return codigo != null && !codigo.isEmpty() && precio > 0;
    }

    // Implementación de Persistible
    @Override
    public void guardar() {
        if (this.validar()) {
            System.out.println("Guardando producto: " + this.codigo);
            // Lógica de persistencia (BD, archivo, etc.)
        }
    }

    @Override
    public void eliminar() {
        System.out.println("Eliminando producto: " + this.codigo);
    }

    @Override
    public void actualizar() {
        System.out.println("Actualizando producto: " + this.codigo);
    }
}
                      

                        /**
 * SOLID - SRP: Single Responsibility Principle
 * ❌ MAL: Una clase hace todo (validación, lógica, persistencia)
 * ✅ BIEN: Separar responsabilidades en clases especializadas
 */

// ❌ MAL - Clase con múltiples responsabilidades
public class EmpleadoMalo {
    public void guardarEnBaseDatos() { /* SQL aquí */ }
    public void validarDatos() { /* Validaciones */ }
    public void enviarEmailBienvenida() { /* Email */ }
    public double calcularSalario() { /* Cálculo */ }
    // Esta clase tiene 4 razones para cambiar!
}

// ✅ BIEN - Responsabilidades separadas

// Solo datos y comportamiento de negocio del empleado
public class Empleado {
    private String rut;
    private String nombre;
    private double salarioBase;

    public double calcularSalarioMensual() {
        return this.salarioBase;
    }
}

// Solo validaciones
public class EmpleadoValidator {
    public boolean validar(Empleado empleado) {
        return empleado.getRut() != null &&
               empleado.getNombre() != null &&
               empleado.getSalarioBase() > 0;
    }

    public List<String> obtenerErrores(Empleado empleado) {
        List<String> errores = new ArrayList<>();
        if (empleado.getRut() == null) errores.add("RUT requerido");
        return errores;
    }
}

// Solo persistencia
public class EmpleadoRepository {
    public void guardar(Empleado empleado) {
        // Solo lógica de base de datos
    }

    public Empleado buscarPorRut(String rut) {
        // Solo consulta BD
        return null;
    }
}

// Solo notificaciones
public class EmpleadoNotificador {
    public void enviarBienvenida(Empleado empleado) {
        // Solo lógica de email
    }
}
                      

                        /**
 * Excepciones Personalizadas
 * Crear excepciones específicas del negocio para mejor manejo de errores
 */

// Excepción base del dominio
public class NegocioException extends RuntimeException {
    private final String codigo;

    public NegocioException(String codigo, String mensaje) {
        super(mensaje);
        this.codigo = codigo;
    }

    public String getCodigo() {
        return codigo;
    }
}

// Excepciones específicas
public class EmpleadoNoEncontradoException extends NegocioException {
    public EmpleadoNoEncontradoException(String rut) {
        super("EMP-001", "Empleado no encontrado con RUT: " + rut);
    }
}

public class ValidacionException extends NegocioException {
    private final List<String> errores;

    public ValidacionException(List<String> errores) {
        super("VAL-001", "Errores de validación");
        this.errores = errores;
    }

    public List<String> getErrores() {
        return errores;
    }
}

// Uso en el servicio
public class EmpleadoService {
    private final EmpleadoRepository repository;

    public Empleado buscarPorRut(String rut) {
        return repository.buscarPorRut(rut)
            .orElseThrow(() -> new EmpleadoNoEncontradoException(rut));
    }

    public void registrar(Empleado empleado) {
        List<String> errores = validator.obtenerErrores(empleado);
        if (!errores.isEmpty()) {
            throw new ValidacionException(errores);
        }
        repository.guardar(empleado);
    }
}

// Manejo en el controller
public class EmpleadoController {
    public void buscar(String rut) {
        try {
            Empleado emp = service.buscarPorRut(rut);
            mostrar(emp);
        } catch (EmpleadoNoEncontradoException e) {
            mostrarError("No encontrado: " + e.getMessage());
        } catch (ValidacionException e) {
            mostrarErrores(e.getErrores());
        }
    }
}
                      

                        @RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    @Autowired
    private UsuarioService usuarioService;

    @GetMapping("/{id}")
    public ResponseEntity<Usuario> obtenerUsuario(@PathVariable Long id) {
        Usuario usuario = usuarioService.buscarPorId(id);
        if (usuario == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(usuario);
    }

    @PostMapping
    public ResponseEntity<Usuario> crearUsuario(@Valid @RequestBody Usuario usuario) {
        Usuario nuevo = usuarioService.guardar(usuario);
        return ResponseEntity.status(HttpStatus.CREATED).body(nuevo);
    }
}
                      

                        @Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {

    // Query methods
    Optional<Usuario> findByEmail(String email);

    List<Usuario> findByActivoTrue();

    // Query personalizada
    @Query("SELECT u FROM Usuario u WHERE u.nombre LIKE %:nombre%")
    List<Usuario> buscarPorNombre(@Param("nombre") String nombre);

    // Query nativa
    @Query(value = "SELECT * FROM usuarios WHERE created_at > :fecha",
           nativeQuery = true)
    List<Usuario> findRecientes(@Param("fecha") LocalDateTime fecha);
}
                      

                        CREATE TABLE usuarios (
    id SERIAL PRIMARY KEY,
    nombre VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    fecha_nacimiento DATE,
    activo BOOLEAN DEFAULT true,
    rol_id INTEGER REFERENCES roles(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    CONSTRAINT chk_email CHECK (email ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$')
);

-- Índices para mejorar rendimiento
CREATE INDEX idx_usuarios_email ON usuarios(email);
CREATE INDEX idx_usuarios_rol ON usuarios(rol_id);
                      

                        SELECT
    d.nombre AS departamento,
    COUNT(e.id) AS total_empleados,
    AVG(e.salario) AS salario_promedio,
    MAX(e.salario) AS salario_maximo,
    MIN(e.fecha_contratacion) AS primera_contratacion
FROM departamentos d
LEFT JOIN empleados e ON d.id = e.departamento_id
WHERE e.activo = true
    AND e.fecha_contratacion >= '2023-01-01'
GROUP BY d.id, d.nombre
HAVING COUNT(e.id) > 5
ORDER BY total_empleados DESC
LIMIT 10;
                      

                        async function fetchUsuarios() {
    try {
        const response = await fetch('https://api.ejemplo.com/usuarios', {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${token}`
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error fetching usuarios:', error);
        throw error;
    }
}

// Uso con POST
async function crearUsuario(usuario) {
    const response = await fetch('https://api.ejemplo.com/usuarios', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(usuario)
    });
    return response.json();
}
                      

                        import { useState, useEffect } from 'react';

function useFetch(url) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        const abortController = new AbortController();

        async function fetchData() {
            try {
                setLoading(true);
                const response = await fetch(url, {
                    signal: abortController.signal
                });
                const json = await response.json();
                setData(json);
                setError(null);
            } catch (err) {
                if (err.name !== 'AbortError') {
                    setError(err.message);
                }
            } finally {
                setLoading(false);
            }
        }

        fetchData();
        return () => abortController.abort();
    }, [url]);

    return { data, loading, error };
}
                      

                        // usuario.js - Módulo con clase
export class Usuario {
    #password;  // Campo privado (ES2022)

    constructor(nombre, email) {
        this.nombre = nombre;
        this.email = email;
        this.createdAt = new Date();
    }

    // Getter
    get info() {
        return `${this.nombre} <${this.email}>`;
    }

    // Método estático
    static validarEmail(email) {
        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
    }

    // Método async
    async guardar() {
        const response = await fetch('/api/usuarios', {
            method: 'POST',
            body: JSON.stringify(this)
        });
        return response.json();
    }
}

// Función helper exportada
export const formatearFecha = (fecha) =>
    new Intl.DateTimeFormat('es-CL').format(fecha);

// Export default
export default Usuario;

// En otro archivo:
// import Usuario, { formatearFecha } from './usuario.js';
                      

                        const productos = [
    { id: 1, nombre: 'Laptop', precio: 999, stock: 5 },
    { id: 2, nombre: 'Mouse', precio: 29, stock: 50 },
    { id: 3, nombre: 'Teclado', precio: 79, stock: 0 },
    { id: 4, nombre: 'Monitor', precio: 299, stock: 10 }
];

// filter - filtrar elementos
const enStock = productos.filter(p => p.stock > 0);

// map - transformar elementos
const nombres = productos.map(p => p.nombre);

// find - encontrar uno
const laptop = productos.find(p => p.id === 1);

// reduce - agregar a un valor
const totalInventario = productos.reduce(
    (total, p) => total + (p.precio * p.stock), 0
);

// Encadenamiento (chaining)
const resumen = productos
    .filter(p => p.stock > 0)
    .map(p => ({
        nombre: p.nombre,
        valor: p.precio * p.stock
    }))
    .sort((a, b) => b.valor - a.valor);

// some / every - validaciones
const hayAgotados = productos.some(p => p.stock === 0);
const todosDisponibles = productos.every(p => p.stock > 0);