Tipos de excepciones: excepciones comprobadas y no comprobadas

En Java, las excepciones se dividen en dos categorías principales: excepciones comprobadas (checked exceptions) y excepciones no comprobadas (unchecked exceptions). Esta clasificación determina cómo se manejan en tiempo de compilación y qué responsabilidades tiene el desarrollador al trabajar con ellas.

Jerarquía de excepciones en Java

Para entender los tipos de excepciones, es importante conocer su jerarquía:

Throwable
├── Error
└── Exception
    └── RuntimeException

La clase Throwable es la superclase de todos los errores y excepciones.
Las clases Error y Exception extienden de Throwable.
La clase RuntimeException extiende de Exception.

Excepciones comprobadas (Checked Exceptions)

Las excepciones comprobadas son aquellas que el compilador obliga a manejar explícitamente. Estas excepciones representan condiciones excepcionales que una aplicación bien escrita debería anticipar y recuperarse de ellas.

Características principales:

Extienden de la clase Exception (pero no de RuntimeException).
El compilador verifica que estas excepciones sean capturadas o declaradas.
Se utilizan para condiciones recuperables que el programa puede manejar.

Ejemplos comunes:

// IOException: ocurre durante operaciones de entrada/salida
try {
    FileReader archivo = new FileReader("documento.txt");
} catch (IOException e) {
    System.out.println("No se pudo abrir el archivo: " + e.getMessage());
}

// SQLException: ocurre durante operaciones con bases de datos
try {
    Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/db", "usuario", "contraseña");
} catch (SQLException e) {
    System.out.println("Error de conexión a la base de datos: " + e.getMessage());
}

Otras excepciones comprobadas comunes incluyen:

ClassNotFoundException
InterruptedException
ParseException

Excepciones no comprobadas (Unchecked Exceptions)

Las excepciones no comprobadas son aquellas que el compilador no obliga a manejar explícitamente. Estas excepciones generalmente representan errores de programación o condiciones que no se pueden recuperar razonablemente.

Características principales:

Son subclases de RuntimeException.
El compilador no verifica si estas excepciones son capturadas o declaradas.
Representan problemas que ocurren debido a errores de programación.

Ejemplos comunes:

// NullPointerException: acceso a un objeto nulo
String texto = null;
int longitud = texto.length(); // Lanza NullPointerException

// ArrayIndexOutOfBoundsException: acceso a un índice fuera de los límites del array
int[] numeros = {1, 2, 3};
int valor = numeros[5]; // Lanza ArrayIndexOutOfBoundsException

// ArithmeticException: operación aritmética inválida
int resultado = 10 / 0; // Lanza ArithmeticException

Otras excepciones no comprobadas comunes incluyen:

IllegalArgumentException
NumberFormatException
ClassCastException
IndexOutOfBoundsException

Comparación entre excepciones comprobadas y no comprobadas

| Característica | Excepciones comprobadas | Excepciones no comprobadas | |----------------|-------------------------|----------------------------| | Verificación en compilación | Sí | No | | Manejo obligatorio | Sí | No | | Superclase | Exception (no RuntimeException) | RuntimeException | | Propósito | Condiciones recuperables externas | Errores de programación | | Declaración con throws | Obligatoria si no se captura | Opcional |

¿Cuándo usar cada tipo?

Excepciones comprobadas: Se utilizan cuando se espera que el código cliente pueda recuperarse de la excepción. Por ejemplo, problemas de conexión, archivos no encontrados o formatos incorrectos.

public void leerArchivo(String ruta) throws IOException {
    // Si no se puede leer el archivo, se lanza IOException
    // El código que llama a este método debe manejar esta excepción
    BufferedReader reader = new BufferedReader(new FileReader(ruta));
    // ...
}

Excepciones no comprobadas: Se utilizan para indicar errores de programación que normalmente no deberían ocurrir si el código está bien escrito. Por ejemplo, acceder a un índice inexistente o dividir por cero.

public double calcularPromedio(int[] valores) {
    // Si valores es null, se lanzará NullPointerException
    // Si valores está vacío, se lanzará ArithmeticException
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return (double) suma / valores.length;
}

Error vs Exception

Aunque los Error también son excepciones no comprobadas, representan condiciones graves que generalmente no deberían ser capturadas:

Los Error indican problemas serios que una aplicación no debería intentar manejar (como OutOfMemoryError o StackOverflowError).
Las Exception indican condiciones que una aplicación podría querer manejar.

// No es recomendable capturar errores, pero es posible
try {
    // Código que podría causar un StackOverflowError
    metodoRecursivo();
} catch (Error e) {
    // No es una buena práctica capturar errores
    System.out.println("Se produjo un error grave: " + e.getMessage());
}

Buenas prácticas

No utilizar excepciones para el flujo de control normal del programa.
Capturar excepciones específicas en lugar de excepciones genéricas.
Crear excepciones personalizadas como excepciones comprobadas si representan condiciones recuperables.
Crear excepciones personalizadas como excepciones no comprobadas si representan errores de programación.
Documentar las excepciones que puede lanzar un método.

// Mal ejemplo: captura genérica
try {
    // Código que puede lanzar múltiples excepciones
} catch (Exception e) {
    // Manejo genérico
}

// Buen ejemplo: capturas específicas
try {
    // Código que puede lanzar múltiples excepciones
} catch (IOException e) {
    // Manejo específico para IOException
} catch (SQLException e) {
    // Manejo específico para SQLException
} catch (RuntimeException e) {
    // Manejo para excepciones no comprobadas
}

Entender la diferencia entre excepciones comprobadas y no comprobadas es fundamental para diseñar un manejo de errores efectivo en aplicaciones Java, permitiendo crear código más robusto y mantenible.

Tipos de excepciones: excepciones comprobadas y no comprobadas

Jerarquía de excepciones en Java

Para entender los tipos de excepciones, es importante conocer su jerarquía:

Throwable
├── Error
└── Exception
    └── RuntimeException

La clase Throwable es la superclase de todos los errores y excepciones.
Las clases Error y Exception extienden de Throwable.
La clase RuntimeException extiende de Exception.

Excepciones comprobadas (Checked Exceptions)

Características principales:

Extienden de la clase Exception (pero no de RuntimeException).
El compilador verifica que estas excepciones sean capturadas o declaradas.
Se utilizan para condiciones recuperables que el programa puede manejar.

Ejemplos comunes:

// IOException: ocurre durante operaciones de entrada/salida
try {
    FileReader archivo = new FileReader("documento.txt");
} catch (IOException e) {
    System.out.println("No se pudo abrir el archivo: " + e.getMessage());
}

// SQLException: ocurre durante operaciones con bases de datos
try {
    Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/db", "usuario", "contraseña");
} catch (SQLException e) {
    System.out.println("Error de conexión a la base de datos: " + e.getMessage());
}

Otras excepciones comprobadas comunes incluyen:

ClassNotFoundException
InterruptedException
ParseException

Excepciones no comprobadas (Unchecked Exceptions)

Características principales:

Son subclases de RuntimeException.
El compilador no verifica si estas excepciones son capturadas o declaradas.
Representan problemas que ocurren debido a errores de programación.

Ejemplos comunes:

// NullPointerException: acceso a un objeto nulo
String texto = null;
int longitud = texto.length(); // Lanza NullPointerException

// ArrayIndexOutOfBoundsException: acceso a un índice fuera de los límites del array
int[] numeros = {1, 2, 3};
int valor = numeros[5]; // Lanza ArrayIndexOutOfBoundsException

// ArithmeticException: operación aritmética inválida
int resultado = 10 / 0; // Lanza ArithmeticException

Otras excepciones no comprobadas comunes incluyen:

IllegalArgumentException
NumberFormatException
ClassCastException
IndexOutOfBoundsException

Comparación entre excepciones comprobadas y no comprobadas

¿Cuándo usar cada tipo?

Excepciones comprobadas: Se utilizan cuando se espera que el código cliente pueda recuperarse de la excepción. Por ejemplo, problemas de conexión, archivos no encontrados o formatos incorrectos.

public void leerArchivo(String ruta) throws IOException {
    // Si no se puede leer el archivo, se lanza IOException
    // El código que llama a este método debe manejar esta excepción
    BufferedReader reader = new BufferedReader(new FileReader(ruta));
    // ...
}

Excepciones no comprobadas: Se utilizan para indicar errores de programación que normalmente no deberían ocurrir si el código está bien escrito. Por ejemplo, acceder a un índice inexistente o dividir por cero.

public double calcularPromedio(int[] valores) {
    // Si valores es null, se lanzará NullPointerException
    // Si valores está vacío, se lanzará ArithmeticException
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return (double) suma / valores.length;
}

Error vs Exception

Aunque los Error también son excepciones no comprobadas, representan condiciones graves que generalmente no deberían ser capturadas:

Los Error indican problemas serios que una aplicación no debería intentar manejar (como OutOfMemoryError o StackOverflowError).
Las Exception indican condiciones que una aplicación podría querer manejar.

// No es recomendable capturar errores, pero es posible
try {
    // Código que podría causar un StackOverflowError
    metodoRecursivo();
} catch (Error e) {
    // No es una buena práctica capturar errores
    System.out.println("Se produjo un error grave: " + e.getMessage());
}

Buenas prácticas

No utilizar excepciones para el flujo de control normal del programa.
Capturar excepciones específicas en lugar de excepciones genéricas.
Crear excepciones personalizadas como excepciones comprobadas si representan condiciones recuperables.
Crear excepciones personalizadas como excepciones no comprobadas si representan errores de programación.
Documentar las excepciones que puede lanzar un método.

// Mal ejemplo: captura genérica
try {
    // Código que puede lanzar múltiples excepciones
} catch (Exception e) {
    // Manejo genérico
}

// Buen ejemplo: capturas específicas
try {
    // Código que puede lanzar múltiples excepciones
} catch (IOException e) {
    // Manejo específico para IOException
} catch (SQLException e) {
    // Manejo específico para SQLException
} catch (RuntimeException e) {
    // Manejo para excepciones no comprobadas
}

Tipos de excepciones: excepciones comprobadas y no comprobadas

Guarda tu progreso

Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.

Progreso guardado

Asistente IA

Ejercicios

Iniciar sesión gratis

Más de 25.000 desarrolladores ya confían en CertiDevs

Jerarquía de excepciones en Java

Para entender los tipos de excepciones, es importante conocer su jerarquía:

Throwable
├── Error
└── Exception
    └── RuntimeException

La clase Throwable es la superclase de todos los errores y excepciones.
Las clases Error y Exception extienden de Throwable.
La clase RuntimeException extiende de Exception.

Excepciones comprobadas (Checked Exceptions)

Características principales:

Extienden de la clase Exception (pero no de RuntimeException).
El compilador verifica que estas excepciones sean capturadas o declaradas.
Se utilizan para condiciones recuperables que el programa puede manejar.

Ejemplos comunes:

// IOException: ocurre durante operaciones de entrada/salida
try {
    FileReader archivo = new FileReader("documento.txt");
} catch (IOException e) {
    System.out.println("No se pudo abrir el archivo: " + e.getMessage());
}

// SQLException: ocurre durante operaciones con bases de datos
try {
    Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/db", "usuario", "contraseña");
} catch (SQLException e) {
    System.out.println("Error de conexión a la base de datos: " + e.getMessage());
}

Otras excepciones comprobadas comunes incluyen:

ClassNotFoundException
InterruptedException
ParseException

Excepciones no comprobadas (Unchecked Exceptions)

Características principales:

Son subclases de RuntimeException.
El compilador no verifica si estas excepciones son capturadas o declaradas.
Representan problemas que ocurren debido a errores de programación.

Ejemplos comunes:

// NullPointerException: acceso a un objeto nulo
String texto = null;
int longitud = texto.length(); // Lanza NullPointerException

// ArrayIndexOutOfBoundsException: acceso a un índice fuera de los límites del array
int[] numeros = {1, 2, 3};
int valor = numeros[5]; // Lanza ArrayIndexOutOfBoundsException

// ArithmeticException: operación aritmética inválida
int resultado = 10 / 0; // Lanza ArithmeticException

Otras excepciones no comprobadas comunes incluyen:

IllegalArgumentException
NumberFormatException
ClassCastException
IndexOutOfBoundsException

Comparación entre excepciones comprobadas y no comprobadas

¿Cuándo usar cada tipo?

Excepciones comprobadas: Se utilizan cuando se espera que el código cliente pueda recuperarse de la excepción. Por ejemplo, problemas de conexión, archivos no encontrados o formatos incorrectos.

public void leerArchivo(String ruta) throws IOException {
    // Si no se puede leer el archivo, se lanza IOException
    // El código que llama a este método debe manejar esta excepción
    BufferedReader reader = new BufferedReader(new FileReader(ruta));
    // ...
}

Excepciones no comprobadas: Se utilizan para indicar errores de programación que normalmente no deberían ocurrir si el código está bien escrito. Por ejemplo, acceder a un índice inexistente o dividir por cero.

public double calcularPromedio(int[] valores) {
    // Si valores es null, se lanzará NullPointerException
    // Si valores está vacío, se lanzará ArithmeticException
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return (double) suma / valores.length;
}

Error vs Exception

Aunque los Error también son excepciones no comprobadas, representan condiciones graves que generalmente no deberían ser capturadas:

Los Error indican problemas serios que una aplicación no debería intentar manejar (como OutOfMemoryError o StackOverflowError).
Las Exception indican condiciones que una aplicación podría querer manejar.

// No es recomendable capturar errores, pero es posible
try {
    // Código que podría causar un StackOverflowError
    metodoRecursivo();
} catch (Error e) {
    // No es una buena práctica capturar errores
    System.out.println("Se produjo un error grave: " + e.getMessage());
}

Buenas prácticas

No utilizar excepciones para el flujo de control normal del programa.
Capturar excepciones específicas en lugar de excepciones genéricas.
Crear excepciones personalizadas como excepciones comprobadas si representan condiciones recuperables.
Crear excepciones personalizadas como excepciones no comprobadas si representan errores de programación.
Documentar las excepciones que puede lanzar un método.

// Mal ejemplo: captura genérica
try {
    // Código que puede lanzar múltiples excepciones
} catch (Exception e) {
    // Manejo genérico
}

// Buen ejemplo: capturas específicas
try {
    // Código que puede lanzar múltiples excepciones
} catch (IOException e) {
    // Manejo específico para IOException
} catch (SQLException e) {
    // Manejo específico para SQLException
} catch (RuntimeException e) {
    // Manejo para excepciones no comprobadas
}

Tipos de excepciones: excepciones comprobadas y no comprobadas

Jerarquía de excepciones en Java

Para entender los tipos de excepciones, es importante conocer su jerarquía:

Throwable
├── Error
└── Exception
    └── RuntimeException

La clase Throwable es la superclase de todos los errores y excepciones.
Las clases Error y Exception extienden de Throwable.
La clase RuntimeException extiende de Exception.

Excepciones comprobadas (Checked Exceptions)

Características principales:

Extienden de la clase Exception (pero no de RuntimeException).
El compilador verifica que estas excepciones sean capturadas o declaradas.
Se utilizan para condiciones recuperables que el programa puede manejar.

Ejemplos comunes:

// IOException: ocurre durante operaciones de entrada/salida
try {
    FileReader archivo = new FileReader("documento.txt");
} catch (IOException e) {
    System.out.println("No se pudo abrir el archivo: " + e.getMessage());
}

// SQLException: ocurre durante operaciones con bases de datos
try {
    Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/db", "usuario", "contraseña");
} catch (SQLException e) {
    System.out.println("Error de conexión a la base de datos: " + e.getMessage());
}

Otras excepciones comprobadas comunes incluyen:

ClassNotFoundException
InterruptedException
ParseException

Excepciones no comprobadas (Unchecked Exceptions)

Características principales:

Son subclases de RuntimeException.
El compilador no verifica si estas excepciones son capturadas o declaradas.
Representan problemas que ocurren debido a errores de programación.

Ejemplos comunes:

// NullPointerException: acceso a un objeto nulo
String texto = null;
int longitud = texto.length(); // Lanza NullPointerException

// ArrayIndexOutOfBoundsException: acceso a un índice fuera de los límites del array
int[] numeros = {1, 2, 3};
int valor = numeros[5]; // Lanza ArrayIndexOutOfBoundsException

// ArithmeticException: operación aritmética inválida
int resultado = 10 / 0; // Lanza ArithmeticException

Otras excepciones no comprobadas comunes incluyen:

IllegalArgumentException
NumberFormatException
ClassCastException
IndexOutOfBoundsException

Comparación entre excepciones comprobadas y no comprobadas

¿Cuándo usar cada tipo?

Excepciones comprobadas: Se utilizan cuando se espera que el código cliente pueda recuperarse de la excepción. Por ejemplo, problemas de conexión, archivos no encontrados o formatos incorrectos.

public void leerArchivo(String ruta) throws IOException {
    // Si no se puede leer el archivo, se lanza IOException
    // El código que llama a este método debe manejar esta excepción
    BufferedReader reader = new BufferedReader(new FileReader(ruta));
    // ...
}

Excepciones no comprobadas: Se utilizan para indicar errores de programación que normalmente no deberían ocurrir si el código está bien escrito. Por ejemplo, acceder a un índice inexistente o dividir por cero.

public double calcularPromedio(int[] valores) {
    // Si valores es null, se lanzará NullPointerException
    // Si valores está vacío, se lanzará ArithmeticException
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return (double) suma / valores.length;
}

Error vs Exception

Aunque los Error también son excepciones no comprobadas, representan condiciones graves que generalmente no deberían ser capturadas:

Los Error indican problemas serios que una aplicación no debería intentar manejar (como OutOfMemoryError o StackOverflowError).
Las Exception indican condiciones que una aplicación podría querer manejar.

// No es recomendable capturar errores, pero es posible
try {
    // Código que podría causar un StackOverflowError
    metodoRecursivo();
} catch (Error e) {
    // No es una buena práctica capturar errores
    System.out.println("Se produjo un error grave: " + e.getMessage());
}

Buenas prácticas

No utilizar excepciones para el flujo de control normal del programa.
Capturar excepciones específicas en lugar de excepciones genéricas.
Crear excepciones personalizadas como excepciones comprobadas si representan condiciones recuperables.
Crear excepciones personalizadas como excepciones no comprobadas si representan errores de programación.
Documentar las excepciones que puede lanzar un método.

// Mal ejemplo: captura genérica
try {
    // Código que puede lanzar múltiples excepciones
} catch (Exception e) {
    // Manejo genérico
}

// Buen ejemplo: capturas específicas
try {
    // Código que puede lanzar múltiples excepciones
} catch (IOException e) {
    // Manejo específico para IOException
} catch (SQLException e) {
    // Manejo específico para SQLException
} catch (RuntimeException e) {
    // Manejo para excepciones no comprobadas
}

Tipos de excepciones: excepciones comprobadas y no comprobadas

Jerarquía de excepciones en Java

Para entender los tipos de excepciones, es importante conocer su jerarquía:

Throwable
├── Error
└── Exception
    └── RuntimeException

La clase Throwable es la superclase de todos los errores y excepciones.
Las clases Error y Exception extienden de Throwable.
La clase RuntimeException extiende de Exception.

Excepciones comprobadas (Checked Exceptions)

Características principales:

Extienden de la clase Exception (pero no de RuntimeException).
El compilador verifica que estas excepciones sean capturadas o declaradas.
Se utilizan para condiciones recuperables que el programa puede manejar.

Ejemplos comunes:

// IOException: ocurre durante operaciones de entrada/salida
try {
    FileReader archivo = new FileReader("documento.txt");
} catch (IOException e) {
    System.out.println("No se pudo abrir el archivo: " + e.getMessage());
}

// SQLException: ocurre durante operaciones con bases de datos
try {
    Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/db", "usuario", "contraseña");
} catch (SQLException e) {
    System.out.println("Error de conexión a la base de datos: " + e.getMessage());
}

Otras excepciones comprobadas comunes incluyen:

ClassNotFoundException
InterruptedException
ParseException

Excepciones no comprobadas (Unchecked Exceptions)

Características principales:

Son subclases de RuntimeException.
El compilador no verifica si estas excepciones son capturadas o declaradas.
Representan problemas que ocurren debido a errores de programación.

Ejemplos comunes:

// NullPointerException: acceso a un objeto nulo
String texto = null;
int longitud = texto.length(); // Lanza NullPointerException

// ArrayIndexOutOfBoundsException: acceso a un índice fuera de los límites del array
int[] numeros = {1, 2, 3};
int valor = numeros[5]; // Lanza ArrayIndexOutOfBoundsException

// ArithmeticException: operación aritmética inválida
int resultado = 10 / 0; // Lanza ArithmeticException

Otras excepciones no comprobadas comunes incluyen:

IllegalArgumentException
NumberFormatException
ClassCastException
IndexOutOfBoundsException

Comparación entre excepciones comprobadas y no comprobadas

¿Cuándo usar cada tipo?

Excepciones comprobadas: Se utilizan cuando se espera que el código cliente pueda recuperarse de la excepción. Por ejemplo, problemas de conexión, archivos no encontrados o formatos incorrectos.

public void leerArchivo(String ruta) throws IOException {
    // Si no se puede leer el archivo, se lanza IOException
    // El código que llama a este método debe manejar esta excepción
    BufferedReader reader = new BufferedReader(new FileReader(ruta));
    // ...
}

Excepciones no comprobadas: Se utilizan para indicar errores de programación que normalmente no deberían ocurrir si el código está bien escrito. Por ejemplo, acceder a un índice inexistente o dividir por cero.

public double calcularPromedio(int[] valores) {
    // Si valores es null, se lanzará NullPointerException
    // Si valores está vacío, se lanzará ArithmeticException
    int suma = 0;
    for (int valor : valores) {
        suma += valor;
    }
    return (double) suma / valores.length;
}

Error vs Exception

Aunque los Error también son excepciones no comprobadas, representan condiciones graves que generalmente no deberían ser capturadas:

Los Error indican problemas serios que una aplicación no debería intentar manejar (como OutOfMemoryError o StackOverflowError).
Las Exception indican condiciones que una aplicación podría querer manejar.

// No es recomendable capturar errores, pero es posible
try {
    // Código que podría causar un StackOverflowError
    metodoRecursivo();
} catch (Error e) {
    // No es una buena práctica capturar errores
    System.out.println("Se produjo un error grave: " + e.getMessage());
}

Buenas prácticas

No utilizar excepciones para el flujo de control normal del programa.
Capturar excepciones específicas en lugar de excepciones genéricas.
Crear excepciones personalizadas como excepciones comprobadas si representan condiciones recuperables.
Crear excepciones personalizadas como excepciones no comprobadas si representan errores de programación.
Documentar las excepciones que puede lanzar un método.

// Mal ejemplo: captura genérica
try {
    // Código que puede lanzar múltiples excepciones
} catch (Exception e) {
    // Manejo genérico
}

// Buen ejemplo: capturas específicas
try {
    // Código que puede lanzar múltiples excepciones
} catch (IOException e) {
    // Manejo específico para IOException
} catch (SQLException e) {
    // Manejo específico para SQLException
} catch (RuntimeException e) {
    // Manejo para excepciones no comprobadas
}

Aprendizajes de esta lección

Identificar la jerarquía de excepciones en Java.
Distinguir entre excepciones comprobadas y no comprobadas.
Comprender cuándo manejar cada tipo de excepción.
Aplicar buenas prácticas para el manejo de excepciones.
Utilizar excepciones personalizadas apropiadamente.
Mejorar la robustez del código mediante el manejo de errores.

Completa Java y certifícate

Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.

Asistente IA

Resuelve dudas al instante

Ejercicios

Practica con proyectos reales

Certificados

Valida tus conocimientos

Comenzar gratis

Más de 25.000 desarrolladores ya se han certificado con CertiDevs

⭐⭐⭐⭐⭐

4.9/5 valoración