.
📚 UNIDAD II: POLIMORFISMO, ERRORES, RECURSIVIDAD Y E/S
Conceptos teóricos completos + Ejercicio final: Exportar tabla USUARIOS a CSV con UTF-8
📖 CONCEPTO: ¿Qué es el Polimorfismo?
▼🎯 Definición
Polimorfismo (del griego: poli = muchas, morphos = formas) es la capacidad de un objeto de adoptar muchas formas. Permite que un mismo método se comporte de manera diferente según el objeto que lo ejecute.
Características principales:
- Una variable de tipo padre puede almacenar objetos de tipo hijo
- El comportamiento se determina en tiempo de ejecución (late binding)
- Permite escribir código más genérico y reutilizable
- Facilita el mantenimiento y la extensión del software
🌟 Ejemplo del mundo real
El método hacerSonido() funciona diferente según el animal:
- 🐕 Perro → "Guau guau"
- 🐈 Gato → "Miau miau"
- 🐄 Vaca → "Muuu"
class Animal {
void hacerSonido() {
System.out.println("El animal hace un sonido");
}
}
// SUBCLASE - Sobrescribe el método
class Perro extends Animal {
@Override
void hacerSonido() {
System.out.println("🐕 Guau guau");
}
}
// USO DEL POLIMORFISMO
Animal miAnimal = new Perro();
miAnimal.hacerSonido(); // Imprime: 🐕 Guau guau
miAnimal.hacerSonido() produce diferentes resultados según el objeto real.📖 Sobrecarga (Overloading)
▼🎯 Definición
La sobrecarga permite tener múltiples métodos con el MISMO nombre pero DIFERENTES parámetros (número, tipo u orden).
Reglas de la sobrecarga:
- Los métodos deben tener el mismo nombre
- Deben tener diferente lista de parámetros
- Pueden tener diferente tipo de retorno
- Pueden tener diferente modificador de acceso
- Ocurre en tiempo de compilación
// Sumar 2 números
int sumar(int a, int b) { return a + b; }
// Sumar 3 números (sobrecarga por cantidad)
int sumar(int a, int b, int c) { return a + b + c; }
// Sumar decimales (sobrecarga por tipo)
double sumar(double a, double b) { return a + b; }
// Sumar con orden diferente
String sumar(String texto, int num) { return texto + num; }
}
📌 Diferencia entre Sobrecarga y Sobrescritura
| Característica | Sobrecarga | Sobrescritura |
|---|---|---|
| Nombre del método | Mismo nombre | Mismo nombre |
| Parámetros | Diferentes | Deben ser iguales |
| Retorno | Puede cambiar | Debe ser igual o subtipo |
| Cuándo ocurre | Compilación | Ejecución |
| Palabra clave | No se usa | @Override |
📖 Variables y Métodos Estáticos (static)
▼🎯 Definición
static significa que el miembro (variable o método) pertenece a la CLASE, no a los objetos individuales. Todos los objetos COMPARTEN el mismo valor.
Características de static:
- Se puede acceder sin crear un objeto:
Clase.metodo() - Una variable static tiene el mismo valor para todos los objetos
- Un método static no puede acceder a miembros no static directamente
- Ideal para contadores, constantes y métodos de utilería
static int totalUsuarios = 0; // Variable compartida
String nombre;
ContadorGlobal(String nombre) {
this.nombre = nombre;
totalUsuarios++; // Incrementa el contador global
}
static void mostrarTotal() {
System.out.println("Total usuarios: " + totalUsuarios);
}
}
// Uso sin crear objeto
ContadorGlobal.mostrarTotal(); // Total usuarios: 0
ContadorGlobal c1 = new ContadorGlobal("A");
ContadorGlobal c2 = new ContadorGlobal("B");
ContadorGlobal.mostrarTotal(); // Total usuarios: 2
⚠️ CONCEPTO: ¿Qué es una Excepción?
▼🎯 Definición
Una excepción es un evento anormal que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de instrucciones. Java permite "atrapar" estos errores para que el programa no se detenga abruptamente.
Jerarquía de Excepciones:
- Throwable → Clase padre de todas las excepciones y errores
- Exception → Excepciones que podemos manejar (checked)
- RuntimeException → Excepciones en tiempo de ejecución (opcionales de manejar)
- Error → Errores graves de la JVM (no se manejan, ej: OutOfMemoryError)
📌 Excepciones más comunes en Java
| Excepción | Cuándo ocurre | Ejemplo |
|---|---|---|
| ArithmeticException | Dividir entre cero | int x = 10 / 0; |
| NullPointerException | Usar una variable que apunta a null | String s = null; s.length(); |
| ArrayIndexOutOfBoundsException | Acceder a índice inválido | int[] arr = new int[5]; arr[10]; |
| NumberFormatException | Convertir texto no numérico | Integer.parseInt("Hola"); |
| SQLException | Error en base de datos | Conexión fallida, consulta incorrecta |
| IOException | Error al leer/escribir archivos | Archivo no encontrado, sin permisos |
📖 Estructura try-catch-finally
▼🎯 Sintaxis y uso
| Palabra clave | Uso | ¿Obligatorio? |
|---|---|---|
try |
Bloque que puede lanzar una excepción | Sí |
catch |
Bloque que maneja la excepción | Opcional (pero debe haber try o finally) |
finally |
Bloque que SIEMPRE se ejecuta (liberar recursos) | Opcional |
throw |
Lanzar una excepción manualmente | - |
throws |
Declarar que un método puede lanzar excepción | - |
try {
int resultado = 10 / 0;
System.out.println("Resultado: " + resultado);
} catch (ArithmeticException e) {
System.out.println("❌ Error: No se puede dividir entre cero");
System.out.println("Detalle: " + e.getMessage());
} finally {
System.out.println("✅ Este bloque SIEMPRE se ejecuta");
}
// Múltiples catch
try {
// código que puede lanzar diferentes excepciones
} catch (SQLException e) {
System.out.println("Error de BD: " + e.getMessage());
} catch (IOException e) {
System.out.println("Error de archivo: " + e.getMessage());
} catch (Exception e) {
System.out.println("Error general: " + e.getMessage());
}
🛠️ Excepciones Personalizadas
▼🎯 ¿Por qué crear nuestras propias excepciones?
Para manejar errores específicos del dominio o reglas de negocio (validaciones, saldos insuficientes, usuarios no encontrados, etc.).
Pasos para crear una excepción personalizada:
- Extender la clase
Exception(checked) oRuntimeException(unchecked) - Crear un constructor que reciba un mensaje
- Llamar a
super(mensaje)para pasar el mensaje a la clase padre
class UsuarioNoEncontradoException extends Exception {
public UsuarioNoEncontradoException(String mensaje) {
super(mensaje);
}
}
// 2. Usarla en un método (throws)
public Usuario buscarUsuario(String usuario) throws UsuarioNoEncontradoException {
Usuario u = dao.buscar(usuario);
if (u == null) {
throw new UsuarioNoEncontradoException("Usuario '" + usuario + "' no existe");
}
return u;
}
// 3. Capturarla (try-catch)
try {
Usuario u = buscarUsuario("admin");
} catch (UsuarioNoEncontradoException e) {
System.out.println("Error: " + e.getMessage());
}
NombreNoReconocidoException para validar nombres con caracteres especiales de lenguas originarias (kichwa, shuar).🔄 CONCEPTO: ¿Qué es la Recursividad?
▼🎯 Definición
La recursividad es una técnica de programación donde un método se llama a sí mismo para resolver un problema, dividiéndolo en subproblemas más pequeños del mismo tipo.
Componentes de un método recursivo:
- Caso base: Condición que detiene la recursión (evita llamadas infinitas). Es la solución más simple del problema.
- Caso recursivo: Llamada a sí mismo con un problema reducido, acercándose al caso base.
📌 Analogía de la recursividad
La recursividad es como mirarse en un espejo frente a otro espejo. Se ven infinitas imágenes reflejadas. Pero si tapas un espejo (caso base), la recursión se detiene.
Otro ejemplo: Las muñecas rusas (Matryoshka) - abres una, dentro hay otra más pequeña, hasta llegar a la más pequeña que ya no se abre.
📖 Ejemplo 1: Factorial (Recursivo)
▼🎯 ¿Qué es el factorial?
El factorial de un número n (escrito n!) es el producto de todos los números enteros positivos desde 1 hasta n.
Fórmula matemática: n! = n × (n-1) × (n-2) × ... × 1
Ejemplo: 5! = 5 × 4 × 3 × 2 × 1 = 120
Definición recursiva: n! = n × (n-1)!, con caso base: 0! = 1 y 1! = 1
public static int factorial(int n) {
// CASO BASE: si n es 0 o 1, el factorial es 1
if (n == 0 || n == 1) {
return 1;
}
// CASO RECURSIVO: n! = n * (n-1)!
return n * factorial(n - 1);
}
// Visualización de factorial(4)
// factorial(4) = 4 × factorial(3)
// = 4 × 3 × factorial(2)
// = 4 × 3 × 2 × factorial(1)
// = 4 × 3 × 2 × 1 = 24
📖 Ejemplo 2: Fibonacci (Recursivo)
▼🎯 ¿Qué es la serie Fibonacci?
La serie Fibonacci es una secuencia donde cada número es la suma de los dos anteriores.
Serie: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...
Definición recursiva: fib(n) = fib(n-1) + fib(n-2), con casos base: fib(0)=0, fib(1)=1
public static int fibonacci(int n) {
// CASOS BASE
if (n == 0) return 0;
if (n == 1) return 1;
// CASO RECURSIVO: fib(n) = fib(n-1) + fib(n-2)
return fibonacci(n - 1) + fibonacci(n - 2);
}
// Visualización de fibonacci(4)
// fib(4) = fib(3) + fib(2)
// fib(4) = (fib(2)+fib(1)) + (fib(1)+fib(0))
// fib(4) = ((fib(1)+fib(0))+1) + (1+0)
// fib(4) = ((1+0)+1) + 1 = 2+1 = 3
📖 Comparativa: Recursividad vs Iteración
▼🎯 Tabla comparativa
| Característica | Recursividad | Iteración (bucles) |
|---|---|---|
| Memoria | Mayor consumo (pila de llamadas) | Menor consumo |
| Velocidad | Más lenta (por las llamadas a función) | Más rápida |
| Código | Más corto, elegante y legible | Más extenso |
| Riesgo | StackOverflowError (si no hay caso base) | Bucle infinito |
| Depuración | Más difícil de seguir | Más fácil |
| Uso ideal | Problemas con estructura recursiva natural (árboles, Torres de Hanói) | Problemas lineales simples |
// FORMA RECURSIVA
int sumaRecursiva(int[] arr, int n) {
if (n <= 0) return 0;
return arr[n-1] + sumaRecursiva(arr, n-1);
}
// FORMA ITERATIVA
int sumaIterativa(int[] arr) {
int suma = 0;
for (int i = 0; i < arr.length; i++) {
suma += arr[i];
}
return suma;
}
📖 CONCEPTO: Entrada y Salida de Datos (E/S)
▼🎯 Definición
- Entrada (Input): Leer datos desde una fuente externa (teclado, archivo, red, base de datos)
- Salida (Output): Escribir datos a un destino (pantalla, archivo, red, base de datos)
Flujos de E/S en Java:
| Tipo | Clases principales | Uso |
|---|---|---|
| Consola (entrada) | Scanner, System.in |
Leer desde el teclado |
| Consola (salida) | System.out, PrintStream |
Imprimir en pantalla |
| Archivos texto | FileReader, FileWriter |
Leer/escribir archivos de texto |
| Archivos buffer | BufferedReader, BufferedWriter |
Más eficiente para archivos grandes |
| Archivos binarios | FileInputStream, FileOutputStream |
Leer/escribir bytes |
📖 Scanner - Leer del teclado
▼Scanner scanner = new Scanner(System.in);
System.out.print("Ingrese su nombre: ");
String nombre = scanner.nextLine();
System.out.print("Ingrese su edad: ");
int edad = scanner.nextInt();
System.out.print("Ingrese su estatura: ");
double estatura = scanner.nextDouble();
System.out.println("Hola " + nombre + ", tienes " + edad + " años");
scanner.close();
nextLine() (String), nextInt() (int), nextDouble() (double), nextBoolean() (boolean), next() (String sin espacios)📖 Leer y escribir archivos de texto
▼📁 Escritura con FileWriter y PrintWriter
try (PrintWriter writer = new PrintWriter(new FileWriter("datos.txt"))) {
writer.println("Nombre: Juan Pérez");
writer.println("Edad: 25 años");
writer.println("Ciudad: Quito");
System.out.println("✅ Archivo guardado correctamente");
} catch (IOException e) {
System.out.println("❌ Error al guardar: " + e.getMessage());
}
📁 Lectura con BufferedReader
try (BufferedReader reader = new BufferedReader(new FileReader("datos.txt"))) {
String linea;
while ((linea = reader.readLine()) != null) {
System.out.println(linea);
}
} catch (IOException e) {
System.out.println("❌ Error al leer: " + e.getMessage());
}
🌐 Codificación UTF-8 para Interculturalidad
▼🎯 ¿Por qué usar UTF-8?
UTF-8 es una codificación que soporta todos los caracteres del mundo, incluyendo letras con tildes, la ñ, y caracteres de lenguas originarias como el kichwa y shuar.
Sin UTF-8: Ñusta → �usta (caracteres corruptos)
Con UTF-8: Ñusta → Ñusta (correcto)
import java.nio.charset.StandardCharsets;
import java.io.*;
try (PrintWriter writer = new PrintWriter(
new OutputStreamWriter(new FileOutputStream("participantes.txt"), StandardCharsets.UTF_8))) {
writer.println("Ñusta,Kichwa,femenino");
writer.println("Atahualpa,Kichwa,masculino");
writer.println("Shakira,Shuar,femenino");
writer.println("Yawaa,Shuar,animal");
System.out.println("✅ Archivo guardado con UTF-8");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
📝 EJERCICIO FINAL: Exportar tabla USUARIOS a CSV
▼🎯 Objetivo del ejercicio
Desarrollar la funcionalidad de exportar los datos de la tabla USUARIOS a un archivo CSV con codificación UTF-8, aplicando todos los conceptos de la Unidad II:
- ✅ Manejo de excepciones (try-catch-finally)
- ✅ Entrada/Salida con archivos (UTF-8)
- ✅ Patrón MVC (Modelo-Vista-Controlador)
- ✅ El archivo debe guardarse en la carpeta Descargas del usuario
📌 PASO 1: MODELO (Usuarios.java) - Agregar este método
public void exportarACSV() {
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
PrintWriter writer = null;
try {
// Obtener la carpeta Descargas del usuario
String userHome = System.getProperty("user.home");
String carpetaDescargas = userHome + "/Downloads";
File dirDescargas = new File(carpetaDescargas);
if (!dirDescargas.exists()) {
carpetaDescargas = userHome + "/Desktop";
}
String rutaArchivo = carpetaDescargas + "/usuarios_export.csv";
// Conectar a la base de datos
con = Conexion.conectar();
String sql = "SELECT id_usuario, nombre, usuario, rol, puntos, estado FROM usuarios";
ps = con.prepareStatement(sql);
rs = ps.executeQuery();
// Crear archivo con codificación UTF-8
writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(rutaArchivo), StandardCharsets.UTF_8));
// Escribir cabecera del CSV
writer.println("ID;NOMBRE;USUARIO;ROL;PUNTOS;ESTADO");
// Escribir cada usuario
int contador = 0;
while (rs.next()) {
writer.printf("%d;%s;%s;%s;%d;%s%n",
rs.getInt("id_usuario"),
rs.getString("nombre"),
rs.getString("usuario"),
rs.getString("rol"),
rs.getInt("puntos"),
rs.getString("estado"));
contador++;
}
writer.flush();
JOptionPane.showMessageDialog(null,
"✅ ¡EXPORTACIÓN EXITOSA!\n\n" +
"📁 Archivo guardado en:\n" + rutaArchivo + "\n\n" +
"📊 Total de usuarios exportados: " + contador + "\n" +
"🌐 Codificación: UTF-8 (soporta ñ, tildes, nombres en Kichwa/Shuar)",
"Exportación CSV", JOptionPane.INFORMATION_MESSAGE);
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"❌ Error al exportar:\n" + e.getMessage(),
"Error", JOptionPane.ERROR_MESSAGE);
} finally {
// Cerrar recursos
try { if (writer != null) writer.close(); } catch (Exception e) {}
try { if (rs != null) rs.close(); } catch (Exception e) {}
try { if (ps != null) ps.close(); } catch (Exception e) {}
try { if (con != null) con.close(); } catch (Exception e) {}
}
}
import java.io.*;import java.nio.charset.StandardCharsets;import javax.swing.JOptionPane;📌 PASO 2: CONTROLADOR (controladorUsuarios.java) - Agregar este método
public void exportarCSV() {
usu.exportarACSV();
}
jrmUsuarios.btndatos_exportarcsv.addActionListener(this);✏️ En el método actionPerformed agrega:
if (e.getSource() == jrmUsuarios.btndatos_exportarcsv) { exportarCSV(); }📌 PASO 3: VISTA (jrmUsuarios.java) - Agregar botón
private void btndatos_exportarcsvActionPerformed(java.awt.event.ActionEvent evt) { }📄 Ejemplo del archivo CSV generado
1;Administrador;admin;ADMIN;0;ACTIVO
2;Michael;michael;ESTUDIANTE;120;ACTIVO
3;Juan;juan;ESTUDIANTE;80;ACTIVO
4;María;maria;ESTUDIANTE;50;ACTIVO
5;Ñusta;nusta;ESTUDIANTE;95;ACTIVO
6;Atahualpa;atahua;ESTUDIANTE;110;ACTIVO
📊 Resumen de lo que se agrega
| Archivo | Método/Elemento | Líneas aprox. | Concepto aplicado |
|---|---|---|---|
Usuarios.java |
exportarACSV() |
~50 líneas | E/S + Excepciones |
controladorUsuarios.java |
exportarCSV() + eventos |
~10 líneas | MVC - Controlador |
jrmUsuarios.java |
Botón + evento | ~15 líneas | MVC - Vista |
- ✔️ Método exportarACSV() en el Modelo (5 pts)
- ✔️ Manejo de excepciones con try-catch-finally (5 pts)
- ✔️ Uso de UTF-8 en el archivo exportado (5 pts)
- ✔️ Método en Controlador y evento del botón (5 pts)
- ✔️ El archivo se guarda en Descargas/Desktop (5 pts)
- ✔️ Código limpio y bien estructurado (5 pts)