Java

Tutorial Java: Excepciones

Java: Aprende a manejar excepciones comprobadas y no comprobadas. Mejora el manejo de errores en tu código con este completo tutorial actualizado.

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

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
}

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

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
}

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

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
}

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

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
}

Aprende Java online

Otras lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Ejercicios de programación de Java

Evalúa tus conocimientos de esta lección Excepciones con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

Java Sintaxis Básica

5h 0m

En esta lección

Objetivos de aprendizaje 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.