Manejo de excepciones en Java [con ejemplos]
Publicado: 2020-11-12Las excepciones son el evento no deseado e inesperado de un programa que nunca desea un programador pero que tiene que lidiar con él muchas veces. El lado positivo es que es posible con el lenguaje orientado a objetos Java mitigar esos eventos no deseados a través de un concepto llamado 'Manejo de excepciones en Java '. No repara la excepción, pero proporciona una forma alternativa de tratarla.
Puede haber muchas razones para que ocurra una excepción, incluida la entrada de datos incorrectos, fallas de hardware, fallas de conexión, caída del servidor, etc. Por lo tanto, el manejo de excepciones es y siempre será importante en el curso del aprendizaje de Java, ya que ayuda a asegurar el funcionamiento normal. flujo de un programa en el momento en que ocurre un evento inesperado. Ignorar las excepciones puede hacer que todo el software se bloquee y puede resultar en la pérdida de datos.
Ahora que tenemos una idea sobre las excepciones y el manejo de excepciones, profundicemos en ello y comprendamos cómo Java ayuda en el manejo de excepciones.
Leer: Preguntas de la entrevista sobre el manejo de excepciones
Tabla de contenido
¿Qué es el manejo de excepciones?
Un desarrollador puede predecir las excepciones que un fragmento de código puede generar durante el tiempo de ejecución. Una de las cosas más importantes sobre las que muchos de los estudiantes se vuelven ambiguos es que todas las excepciones ocurren durante el tiempo de ejecución y no en el momento de la compilación. Java puede manejar excepciones solo durante el tiempo de ejecución. Hay ciertas palabras clave que se usan en un programa Java para crear un bloque de manejo de excepciones.
java.lang.Exception es la clase principal de todas las clases de excepción. La clase Exception es una subclase de la clase Throwable integrada , que es una subclase de la clase Object . Además de Excepción, Throwable también tiene otra clase, es decir, Error, que es una condición anormal durante la ejecución del programa que no puede ser manejada por programas Java, que es la principal diferencia entre Error y Excepciones.
Como se muestra en la figura anterior, hay principalmente dos categorías de Excepciones en Java. En la siguiente sección, veremos en detalle los tipos de excepciones en Java.
Excepciones de Java
Las causas fundamentales de las excepciones son las causadas por el programador o por recursos físicos que han fallado debido a alguna razón. En base a esto, existen principalmente dos categorías de Excepciones en Java, como se detalla a continuación:
- excepción comprobada
- excepción no verificada
1. Excepción marcada
Las excepciones verificadas se conocen como 'excepciones en tiempo de compilación', ya que el compilador las verifica durante la compilación para monitorear si el programador maneja la excepción. A continuación, el sistema muestra un error de compilación.
Algunos ejemplos de estas excepciones son IOException , Leer: Ideas de proyectos Java para principiantes
2. Excepción no verificada
Las excepciones no verificadas se denominan 'Excepciones de tiempo de ejecución' ya que ocurren durante el tiempo de ejecución del programa. Las excepciones no verificadas normalmente se ignoran durante la compilación y no se verifican.
Ejemplos de estas excepciones pueden ser errores en un programa, como errores lógicos, o el uso de API incorrectas que no están bajo el control de un programador y requieren que un administrador del sistema las rectifique.
Excepción marcada vs no marcada
| Puntos Diferenciadores | Excepción marcada Excepción no verificada tiempo de manipulación | Las excepciones verificadas se verifican y manejan en el momento de la compilación. | Las excepciones no verificadas no se verifican en el momento de la compilación. |
| Identificación de excepción | El programa da un error de compilación si un método arroja una excepción comprobada. | El programa compila bien ya que el compilador no puede verificar la excepción. | |
| Herencia | No heredan la clase RuntimeException. | Son las subclases de la clase RuntimeException. | |
| Rol del desarrollador | Puede ser manejado por los desarrolladores. | No puede ser manejado por los desarrolladores. |
Comprender las excepciones es el paso principal antes de manejarlas.
¿Cómo ayuda Java en el manejo de excepciones?
Ahora que sabemos que hay dos tipos de excepciones en Java, a saber, marcadas y no marcadas. Si un método arroja una excepción verificada, debe manejarse con un bloque try-catch o debe declararse la palabra clave ' lanzar' para evitar un error de compilación en un programa.
Ejemplo de una excepción marcada:
Este es un programa de lectura de un archivo llamado 'Java'. Hay tres lugares donde se lanza una excepción comprobada:
- FileInputStream: se utiliza para especificar la ruta del archivo y el nombre de FileNotFoundException .
- El método read(): Al leer el contenido del archivo, se genera una IOException ;
iii. El método close(): cerrar el flujo de entrada del archivo lanza IOException .
importar java.io.*;
ejemplo de clase {
public static void principal( String args[])
{
FileInputStream fis = nulo ;
/*El constructor FileInputStream(File filename)
* lanza una excepción comprobada FileNotFoundException */
fis = new FileInputStream ( "B:/java.txt" );
intk ;
/* El método read() de la clase FileInputStream lanza
* una excepción comprobada: IOException
*/
while (( k = fis.read() ) != – 1 )
{
sistema _ fuera _ imprimir (( char )k);
}
/*El método close() cierra el flujo de entrada del archivo
* lanza IOException*/
fis.cerrar();
}
}
Salida del programa anterior:
Se encontró una excepción en el subproceso "principal" java.lang. Error : problemas de compilación no resueltos :
Excepción no controlada FileNotFoundException encontrada
Excepción no controlada IOException encontrada
Excepción no controlada IOException encontrada
El motivo de este error de compilación: No declaración o manejo de las excepciones.
Debe leer: Proyectos Java GitHub
Métodos de manejo de excepciones
Hay dos formas en que se pueden manejar las excepciones que se describen a continuación:
Método 1: declarar la palabra clave de excepción 'throws'
En el programa anterior, las tres excepciones marcadas están dentro del método main(). Por lo tanto, una forma de evitar el error de compilación es declarar la excepción en el método usando la palabra clave 'throws'. Como IOException es una clase principal de FileNotFoundException, también lo cubrirá.
Programa actualizado usando la palabra clave throws:
importar java.io.*;
ejemplo de clase {
public static void main( String args[]) lanza IOException
{
FileInputStream fis = nulo ;
fis = new FileInputStream ( "B:/java.txt" );
intk ;
while (( k = fis.read() ) != – 1 )
{
sistema _ fuera _ imprimir (( char )k);
}
fis.cerrar();
}
}
Producción:
Muestra el contenido del archivo en la pantalla.
Método 2: Manejar excepciones usando bloques try-catch.
Este es un enfoque más avanzado que el anterior y una de las mejores prácticas de manejo de excepciones . El código de programa modificado, incluidos los bloques try-catch, es el siguiente:
importar java.io.*;
ejemplo de clase {
public static void principal( String args[])
{
FileInputStream fis = nulo ;
prueba {
fis = new FileInputStream ( "B:/java.txt" );
} captura ( FileNotFoundException fnfe){
sistema _ out .println( “El archivo no es “ +
“presente en la ruta especificada” );
}
intk ;
prueba {
while (( k = fis.read() ) != – 1 )
{
sistema _ fuera _ imprimir (( char )k);
}
fis.cerrar();
} captura ( IOException ioe){
sistema _ out .println( “Error de E/S” +ioe);
}
}
}
Producción:
Este código finalmente mostrará el contenido del archivo.
Ejemplo de una excepción no verificada
Las excepciones no verificadas no se verifican en el momento de la compilación. El programa no dará un error de compilación si no se declara o maneja y funcionará bien. El trabajo del desarrollador es predecir las condiciones que pueden ocurrir de antemano causando tales excepciones y manejarlas. Todas las excepciones no verificadas son subclases de la clase RuntimeException .
ejemplo de clase {
public static void principal( String args[])
{
int numero1= 10 ;
int numero2= 0 ;
/*Dividiendo cualquier número con 0
* Lanzará ArithmeticException
*/
int res=num1/num2;
sistema _ fuera .println(res);
}
}
El código se compilará correctamente con este código, pero durante el tiempo de ejecución arrojaría una ArithmeticException ya que las excepciones no verificadas no se verifican en el momento de la compilación. Echemos un vistazo a otro ejemplo.
ejemplo de clase {
public static void principal( String args[])
{
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
/* El arreglo tiene 5 elementos pero queremos
* muestra el valor del octavo elemento. arrojará
* ArrayIndexOutOfBoundsException
*/
sistema _ fuera .println(arr[ 7 ]);
}
}
Este código también se compilará correctamente, ya que ArrayIndexOutOfBoundsException es una excepción no verificada.
Aquí, para manejar Excepciones no verificadas, debe mostrarse un mensaje de excepción al usuario que desea mostrar, pero no existe en la matriz.
Manejo de la excepción del código anterior con el bloque try-catch
ejemplo de clase {
public static void principal( String args[]) {
prueba {
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
sistema _ fuera .println(arr[ 7 ]);
}
captura ( ArrayIndexOutOfBoundsException e){
sistema _ out .println( "El índice especificado no existe" +
"en la matriz". );
}
}
}
Producción:
El índice especificado no existe en la matriz.
Nota: Puede haber múltiples bloques catch dentro de un bloque try para manejar diferentes excepciones.
Método 3 : usar la palabra clave 'finalmente'
A veces sucede que es necesario ejecutar un código incluso si se produce una excepción. Aquí es donde se utiliza la palabra clave final . Aquí hay un código típico con la palabra clave 'finally'.
public int getPlayerScore(String playerFile)
lanza FileNotFoundException {
Contenido del escáner = nulo;
tratar {
contenido = nuevo escáner ( nuevo archivo (archivo de jugador));
return Integer.parseInt(contents.nextLine());
} finalmente {
if (contenido != nulo ) {
contenido.cerrar();
}
}
}
Aquí, el bloque final indica el código que queremos que Java ejecute al intentar leer el archivo.
Incluso si se lanza una excepción FileNotFoundException , Java llamará al contenido de finalmente .
Podemos manejar la excepción modificando el código de la siguiente manera:
public int PlayerScore(String playerRuns) {
Contenido del escáner;
tratar {
contenidos = nuevo escáner (nuevo archivo (playerRuns));
return Integer.parseInt(contents.nextLine());
} captura (Excepción FileNotFoundException noFile) {
logger.warn("Archivo no encontrado");
devolver 0;
} finalmente {
tratar {
if (contenido != nulo) {
contenido.cerrar();
}
} captura (IOException ioexc) {
logger.error(“No se pudo cerrar el lector.”, ioexc);
}
}
}
Conclusión
Con este artículo, hemos tratado de repasar los conceptos básicos de errores y excepciones y el manejo de excepciones en Java . Esperamos que esta guía le dé una buena idea de esta característica única que ofrece Java y que ahora pueda manejar las excepciones y recuperarse mejor de ellas. Conclusión
Java proporciona formas de manejar las excepciones, desde las específicas hasta las genéricas. Las excepciones que no se pueden predecir fácilmente por adelantado se denominan excepciones no controladas. La captura de todas las excepciones ofrece visibilidad al equipo de desarrollo sobre la calidad del código y las causas raíz de los errores que se pueden corregir rápidamente.
Si está interesado en obtener más información sobre Java, desarrollo de pila completa, consulte el Diploma PG de upGrad & IIIT-B en desarrollo de software de pila completa. Está cuidadosamente seleccionado para profesionales y asegura un apoyo profesional de 360 grados e incluye proyectos en vivo para trabajar. Al final del curso, podrá diseñar y crear aplicaciones como Swiggy, IMDB, etc.
¡No suena emocionante!-