Manejo de errores en Java

Manejo de errores en Java: guía completa para principiantes

En Java, los programas pueden enfrentar situaciones inesperadas durante su ejecución, como división por cero, archivos inexistentes o datos inválidos. Estas situaciones se conocen como errores o excepciones.

El manejo adecuado de errores permite que un programa no se detenga inesperadamente y pueda recuperarse de manera controlada.

En este artículo se explican los conceptos clave sobre manejo de errores en Java, incluyendo:

  • qué son las excepciones
  • try y catch
  • finally
  • excepciones personalizadas

Qué son las excepciones

Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal del mismo.

Existen varios tipos de excepciones en Java:

  • Checked exceptions: deben ser declaradas o manejadas (ejemplo: IOException)
  • Unchecked exceptions: ocurren en tiempo de ejecución y no requieren declaración (ejemplo: ArithmeticException)

Ejemplo de excepción:

int a = 10;
int b = 0;
int resultado = a / b; // Esto genera ArithmeticException

Si no se maneja, el programa terminará con un error.

try y catch

El bloque try permite envolver el código que puede generar una excepción, mientras que catch captura y maneja la excepción.

Sintaxis básica:

try {
    // código que puede generar excepción
} catch (TipoDeExcepcion e) {
    // manejo de la excepción
}

Ejemplo:

try {
    int division = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error: división por cero");
}

Salida:

Error: división por cero

Se puede capturar distintos tipos de excepciones con varios bloques catch:

try {
    int[] numeros = {1, 2, 3};
    System.out.println(numeros[5]);
} catch (ArithmeticException e) {
    System.out.println("Error aritmético");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Índice fuera de rango");
}

finally

El bloque finally se ejecuta siempre, independientemente de que ocurra o no una excepción.
Se utiliza para liberar recursos como archivos o conexiones de base de datos.

Ejemplo:

try {
    int division = 10 / 2;
    System.out.println("Resultado: " + division);
} catch (ArithmeticException e) {
    System.out.println("Error en la división");
} finally {
    System.out.println("Bloque finally ejecutado");
}

Salida:

Resultado: 5
Bloque finally ejecutado

Excepciones personalizadas

Java permite crear excepciones propias para manejar errores específicos de tu aplicación. Para ello se extiende la clase Exception o RuntimeException.

Ejemplo:

class EdadNoValidaException extends Exception {
    public EdadNoValidaException(String mensaje) {
        super(mensaje);
    }
}

Uso de la excepción personalizada:

public class ValidarEdad {
    public static void validarEdad(int edad) throws EdadNoValidaException {
        if (edad < 18) {
            throw new EdadNoValidaException("La edad debe ser mayor o igual a 18");
        }
        System.out.println("Edad válida");
    }

    public static void main(String[] args) {
        try {
            validarEdad(15);
        } catch (EdadNoValidaException e) {
            System.out.println("Excepción: " + e.getMessage());
        }
    }
}

Salida:

Excepción: La edad debe ser mayor o igual a 18
  • throw genera la excepción
  • throws indica que el método puede lanzar una excepción

Ejemplo completo de manejo de errores

import java.util.Scanner;

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

        try {
            System.out.print("Ingrese un número: ");
            int numero = sc.nextInt();
            int resultado = 100 / numero;
            System.out.println("Resultado: " + resultado);
        } catch (ArithmeticException e) {
            System.out.println("Error: no se puede dividir por cero");
        } catch (Exception e) {
            System.out.println("Error: entrada inválida");
        } finally {
            System.out.println("Programa finalizado");
            sc.close();
        }
    }
}

Repaso de esta lección

El manejo de errores en Java permite crear programas más seguros y estables, capaces de enfrentar situaciones inesperadas. Los conceptos clave son:

  • Excepciones: eventos que interrumpen la ejecución del programa
  • try y catch: capturan y manejan errores
  • finally: ejecuta código independientemente de que ocurra una excepción
  • Excepciones personalizadas: permiten definir reglas específicas de error para tu aplicación

Dominar el manejo de errores es esencial para escribir programas robustos y confiables en Java.

Volver al indice de Programación en Java.

Scroll to Top