// ESTRUCTURA DE DIRECTORIOS (Sistema de archivos)
src/
├── com/
│   └── miapp/
│       ├── model/
│       │   ├── Usuario.java
│       │   └── Producto.java
│       ├── service/
│       │   ├── UsuarioService.java
│       │   └── ProductoService.java
│       ├── util/
│       │   ├── Validador.java
│       │   └── Calculadora.java
│       └── main/
│           └── MainApp.java

// DECLARACIÓN DE PAQUETE (en cada archivo .java)
package com.miapp.model;  // En Usuario.java

// IMPORTACIÓN DE CLASES
import java.util.ArrayList;     // Import específico
import java.util.*;            // Import de todo el paquete
import com.miapp.model.Usuario; // Import de nuestro propio paquete

// IMPORT ESTÁTICO (para métodos/constantes estáticas)
import static java.lang.Math.PI;
import static java.lang.Math.pow;

// CLASE PRINCIPAL QUE USA LOS PAQUETES
package com.miapp.main;

import com.miapp.model.Usuario;
import com.miapp.model.Producto;
import com.miapp.service.UsuarioService;
import static java.lang.System.out;

public class MainApp {
    public static void main(String[] args) {
        // Usar clases importadas
        Usuario usuario = new Usuario("Juan", "juan@email.com");
        UsuarioService service = new UsuarioService();
        
        // Usar import estático
        out.println("PI = " + PI);
        out.println("2^3 = " + pow(2, 3));
    }
}

// JERARQUÍA DE EXCEPCIONES
Throwable (clase base)
├── Error (errores graves, no se deben capturar)
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
└── Exception (excepciones recuperables)
    ├── RuntimeException (unchecked - no requiere declaración)
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   ├── ArithmeticException
    │   ├── IllegalArgumentException
    │   └── ...
    └── IOException (checked - requiere manejo)
        ├── FileNotFoundException
        ├── EOFException
        └── ...

// EJEMPLOS COMPLETOS

// 1. EXCEPCIÓN CHECKED (obligatorio manejar)
public void leerArchivo(String ruta) {
    try {
        FileReader reader = new FileReader(ruta);
        // Leer archivo...
    } catch (FileNotFoundException e) {
        System.err.println("Archivo no encontrado: " + e.getMessage());
    } catch (IOException e) {
        System.err.println("Error de E/S: " + e.getMessage());
    }
}

// 2. EXCEPCIÓN UNCHECKED (opcional manejar)
public int dividir(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Divisor no puede ser cero");
    }
    return a / b;
}

// 3. MULTI-CATCH (Java 7+)
try {
    // Código que puede lanzar múltiples excepciones
} catch (NullPointerException | IllegalArgumentException e) {
    System.err.println("Error de argumento: " + e.getMessage());
}

// 4. TRY-WITH-RESOURCES (Java 7+)
try (FileReader reader = new FileReader("archivo.txt");
     BufferedReader br = new BufferedReader(reader)) {
    String linea;
    while ((linea = br.readLine()) != null) {
        System.out.println(linea);
    }
} catch (IOException e) {
    System.err.println("Error al leer archivo: " + e.getMessage());
}

// 5. EXCEPCIONES PERSONALIZADAS
class SaldoInsuficienteException extends Exception {
    private double saldo;
    private double montoRequerido;
    
    public SaldoInsuficienteException(double saldo, double montoRequerido) {
        super("Saldo insuficiente: $" + saldo + ", se requiere: $" + montoRequerido);
        this.saldo = saldo;
        this.montoRequerido = montoRequerido;
    }
    
    public double getSaldo() { return saldo; }
    public double getMontoRequerido() { return montoRequerido; }
}

// USO DE EXCEPCIÓN PERSONALIZADA
public void retirar(double cantidad) throws SaldoInsuficienteException {
    if (cantidad > saldo) {
        throw new SaldoInsuficienteException(saldo, cantidad);
    }
    saldo -= cantidad;
}

// ENUM BÁSICO
public enum DiaSemana {
    LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO
}

// ENUM CON ATRIBUTOS Y MÉTODOS
public enum EstadoPedido {
    PENDIENTE("En espera de procesamiento", 1),
    PROCESANDO("En preparación", 2),
    ENVIADO("En camino al cliente", 3),
    ENTREGADO("Entregado satisfactoriamente", 4),
    CANCELADO("Pedido cancelado", 0);
    
    private final String descripcion;
    private final int prioridad;
    
    EstadoPedido(String descripcion, int prioridad) {
        this.descripcion = descripcion;
        this.prioridad = prioridad;
    }
    
    public String getDescripcion() { return descripcion; }
    public int getPrioridad() { return prioridad; }
    
    public boolean esFinal() {
        return this == ENTREGADO || this == CANCELADO;
    }
}

// ENUM CON MÉTODOS ABSTRACTOS
public enum OperacionMatematica {
    SUMA("+") {
        public double aplicar(double x, double y) { return x + y; }
    },
    RESTA("-") {
        public double aplicar(double x, double y) { return x - y; }
    },
    MULTIPLICACION("*") {
        public double aplicar(double x, double y) { return x * y; }
    },
    DIVISION("/") {
        public double aplicar(double x, double y) { 
            if (y == 0) throw new ArithmeticException("División por cero");
            return x / y; 
        }
    };
    
    private final String simbolo;
    
    OperacionMatematica(String simbolo) {
        this.simbolo = simbolo;
    }
    
    public String getSimbolo() { return simbolo; }
    
    // Método abstracto que cada constante debe implementar
    public abstract double aplicar(double x, double y);
}

// USO DE ENUMS
public class EjemploEnums {
    public static void main(String[] args) {
        // Valores básicos
        DiaSemana hoy = DiaSemana.LUNES;
        System.out.println("Hoy es: " + hoy);
        
        // Iterar sobre todos los valores
        for (DiaSemana dia : DiaSemana.values()) {
            System.out.println(dia);
        }
        
        // Enums avanzados
        EstadoPedido estado = EstadoPedido.PROCESANDO;
        System.out.println("Estado: " + estado);
        System.out.println("Descripción: " + estado.getDescripcion());
        System.out.println("Es estado final: " + estado.esFinal());
        
        // Switch con enum
        switch (estado) {
            case PENDIENTE:
                System.out.println("El pedido está pendiente");
                break;
            case PROCESANDO:
                System.out.println("El pedido se está procesando");
                break;
            case ENTREGADO:
                System.out.println("¡Pedido entregado!");
                break;
        }
        
        // Enum con métodos
        OperacionMatematica op = OperacionMatematica.SUMA;
        double resultado = op.aplicar(10, 5);
        System.out.println("10 " + op.getSimbolo() + " 5 = " + resultado);
        
        // Comparación de enums
        if (estado == EstadoPedido.PROCESANDO) {
            System.out.println("El pedido está en proceso");
        }
        
        // Convertir String a enum
        String texto = "ENTREGADO";
        EstadoPedido estadoDesdeTexto = EstadoPedido.valueOf(texto);
        System.out.println("Estado desde texto: " + estadoDesdeTexto);
    }
}

// AUTOBOXING Y UNBOXING (Java 5+)
// Autoboxing: conversión automática primitivo → wrapper
Integer numeroObj = 42;        // Equivale a: Integer.valueOf(42)
Double precioObj = 19.99;      // Equivale a: Double.valueOf(19.99)
Boolean esVerdadero = true;    // Equivale a: Boolean.valueOf(true)

// Unboxing: conversión automática wrapper → primitivo
int numero = numeroObj;        // Equivale a: numeroObj.intValue()
double precio = precioObj;     // Equivale a: precioObj.doubleValue()
boolean valor = esVerdadero;   // Equivale a: esVerdadero.booleanValue()

// MÉTODOS ÚTILES DE CLASES WRAPPER

// 1. Conversión de String a tipos numéricos
String textoNumero = "123";
int valorInt = Integer.parseInt(textoNumero);      // 123
double valorDouble = Double.parseDouble("3.14");   // 3.14
boolean valorBool = Boolean.parseBoolean("true");  // true

// 2. Conversión a String
String str1 = Integer.toString(456);        // "456"
String str2 = Double.toString(2.718);       // "2.718"
String str3 = Boolean.toString(false);      // "false"

// 3. Comparación de objetos
Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;

System.out.println(a == b);     // true (cache de -128 a 127)
System.out.println(c == d);     // false (fuera del cache)
System.out.println(c.equals(d)); // true (comparación por valor)

// 4. Constantes útiles
System.out.println("Máximo int: " + Integer.MAX_VALUE);     // 2147483647
System.out.println("Mínimo int: " + Integer.MIN_VALUE);     // -2147483648
System.out.println("Bytes en int: " + Integer.BYTES);       // 4
System.out.println("Bits en int: " + Integer.SIZE);         // 32

// 5. Métodos de Character
char letra = 'A';
System.out.println(Character.isLetter(letra));      // true
System.out.println(Character.isDigit(letra));       // false
System.out.println(Character.isUpperCase(letra));   // true
System.out.println(Character.toLowerCase(letra));   // 'a'

// USO EN COLECCIONES (necesitan objetos)
List numeros = new ArrayList<>();
numeros.add(1);    // Autoboxing: int → Integer
numeros.add(2);
numeros.add(3);

int suma = 0;
for (Integer num : numeros) {
    suma += num;   // Unboxing: Integer → int
}
System.out.println("Suma: " + suma);

// COMPARACIÓN SEGURA (evitar NullPointerException)
Integer posibleNull = obtenerNumero();
int valorSeguro = (posibleNull != null) ? posibleNull : 0;

// MÉTODOS DE CONVERSIÓN ADICIONALES
int hex = Integer.parseInt("FF", 16);      // 255 en hexadecimal
int bin = Integer.parseInt("1010", 2);     // 10 en binario
String binStr = Integer.toBinaryString(10); // "1010"
String hexStr = Integer.toHexString(255);   // "ff"

// WRAPPER PARA TIPOS GENÉRICOS
public class Caja {
    private T valor;
    
    public Caja(T valor) {
        this.valor = valor;
    }
    
    public double obtenerValorDouble() {
        return valor.doubleValue();  // Método de Number
    }
}

Caja cajaEntero = new Caja<>(100);
Caja cajaDouble = new Caja<>(3.14);