Java- de Cero a Profesional

Manejo de Excepciones

Tipos de excepciones

En Java, las excepciones son problemas que pueden ocurrir durante la ejecución de un programa y que interrumpen el flujo normal de ejecución. Hay diferentes tipos de excepciones en Java, y cada una de ellas representa un escenario diferente donde puede ocurrir un problema.

Categorías de Excepciones en Java

  1. Excepciones Controladas (Checked Exceptions):

    • Son aquellas que el compilador obliga a manejar utilizando try-catch o declarando en la firma del método que pueden lanzar estas excepciones.

  2. Excepciones No Controladas (Unchecked Exceptions):

    • Son aquellas que no están obligadas a ser manejadas explícitamente. Generalmente son subclases de RuntimeException.

  3. Errores (Errors):

    • Representan problemas graves que normalmente están fuera del control del programador y que no deberían manejarse en tiempo de ejecución.

Ejemplos de Excepciones

  1. Excepciones Controladas:

    • IOException, SQLException, etc.

  2. Excepciones No Controladas:

    • NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, etc.

  3. Errores:

    • OutOfMemoryError, StackOverflowError, etc.

Ejemplo de Código

				
					import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;

public class TiposDeExcepciones {
    public static void main(String[] args) {
        try {
            // Excepción Controlada: FileNotFoundException
            File archivo = new File("archivo.txt");
            FileReader lector = new FileReader(archivo);

            // Excepción No Controlada: NullPointerException
            String texto = null;
            System.out.println(texto.length());

        } catch (FileNotFoundException e) {
            System.out.println("El archivo no se encontró.");
        } catch (NullPointerException e) {
            System.out.println("Se produjo una NullPointerException.");
        } finally {
            System.out.println("Esto se ejecuta siempre, haya excepción o no.");
        }
    }
}

Explicación del Código

  1. Se intenta leer un archivo que no existe, lo que puede arrojar una FileNotFoundException.
  2. Se intenta acceder a la longitud de una cadena nula, lo que resulta en una NullPointerException.
  3. Ambas excepciones se manejan utilizando bloques try-catch.
  4. El bloque finally se ejecuta siempre, independientemente de si ocurre una excepción o no.

Try, catch, finally

En Java, los bloques try, catch y finally se utilizan para manejar excepciones y realizar acciones de limpieza, garantizando que cierto código se ejecute correctamente incluso si ocurre una excepción.

Uso de try-catch-finally

				
					public class ManejoExcepciones {
    public static void main(String[] args) {
        try {
            // Bloque try: código que puede lanzar una excepción
            int resultado = dividir(10, 0); // Intenta dividir por cero
            System.out.println("Resultado: " + resultado);
        } catch (ArithmeticException e) {
            // Bloque catch: maneja la excepción
            System.out.println("Error: División por cero");
        } finally {
            // Bloque finally: se ejecuta siempre, haya excepción o no
            System.out.println("¡Esto se ejecuta siempre!");
        }
    }

    public static int dividir(int numerador, int denominador) {
        return numerador / denominador;
    }
}

Explicación del Código

  1. Bloque try: Contiene el código que puede lanzar una excepción.

    • En este caso, intentamos dividir por cero, lo que lanzará una ArithmeticException.

  2. Bloque catch: Maneja la excepción capturando el tipo específico de excepción.

    • Si ocurre una excepción, se ejecuta este bloque para manejarla.

  3. Bloque finally: Se ejecuta siempre, haya ocurrido una excepción o no.

    • Se utiliza para realizar acciones de limpieza, como cerrar recursos, que deben ejecutarse independientemente de si hay una excepción o no.

Operadores (aritméticos, lógicos, relacionales, de asignación)

En Java, throw y throws son palabras clave que se utilizan en el manejo de excepciones para controlar y propagar errores en un programa.

throw

La palabra clave throw se utiliza para lanzar una excepción explícitamente en un bloque de código.

				
					public class ThrowEjemplo {
    public static void main(String[] args) {
        int edad = -10;

        try {
            if (edad < 0) {
                throw new IllegalArgumentException("La edad no puede ser negativa");
            }
            System.out.println("Edad: " + edad);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

En este ejemplo:

  • Si la edad es negativa, se lanza una excepción IllegalArgumentException.
  • Esta excepción se captura en el bloque catch y se imprime el mensaje de error.

throws

La palabra clave throws se utiliza en la firma del método para indicar que un método puede lanzar una excepción particular.

				
					import java.io.FileNotFoundException;

public class ThrowsEjemplo {
    public static void main(String[] args) {
        try {
            leerArchivo("archivo.txt");
        } catch (FileNotFoundException e) {
            System.out.println("Error: Archivo no encontrado");
        }
    }

    public static void leerArchivo(String nombreArchivo) throws FileNotFoundException {
        // Simulamos la lectura de un archivo
        throw new FileNotFoundException("Archivo " + nombreArchivo + " no encontrado");
    }
}

En este ejemplo:

  • El método leerArchivo() declara que puede lanzar una excepción FileNotFoundException utilizando la palabra clave throws.
  • Cuando se llama a este método en main(), el compilador sabe que debe manejar esta excepción o propagarla.

Creación de excepciones personalizadas

En Java, puedes crear tus propias excepciones personalizadas para manejar situaciones específicas de tu aplicación que no están cubiertas por las excepciones estándar de Java.

Creación de una Excepción Personalizada

				
					// Definición de la excepción personalizada
class MiExcepcion extends Exception {
    public MiExcepcion(String mensaje) {
        super(mensaje);
    }
}

public class ExcepcionPersonalizada {
    public static void main(String[] args) {
        try {
            throw new MiExcepcion("¡Esto es una excepción personalizada!");
        } catch (MiExcepcion e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

En este ejemplo:

  • Se define una clase MiExcepcion que extiende Exception, lo que la convierte en una excepción personalizada.
  • Se proporciona un constructor que acepta un mensaje de error.
  • En el método main(), se lanza una instancia de MiExcepcion.
  • La excepción se captura en el bloque catch y se imprime el mensaje de error.

Uso de Excepciones Personalizadas

Puedes usar tus excepciones personalizadas en cualquier lugar de tu código donde necesites manejar situaciones específicas.

				
					class Calculadora {
    public static int dividir(int numerador, int denominador) throws MiExcepcion {
        if (denominador == 0) {
            throw new MiExcepcion("¡División por cero no permitida!");
        }
        return numerador / denominador;
    }
}

public class UsoExcepcionPersonalizada {
    public static void main(String[] args) {
        try {
            int resultado = Calculadora.dividir(10, 0);
            System.out.println("Resultado: " + resultado);
        } catch (MiExcepcion e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Recursos