Hay dos tipos de excepciones: excepción marcada y excepción no controlada. En esta guía lo discutiremos. El principal diferencia entre excepción seleccionada y no seleccionada es que las excepciones marcadas se comprueban durante la compilación, mientras que las excepciones no marcadas se comprueban durante la ejecución.

¿Qué son las excepciones controladas?

Las excepciones seleccionadas se comprueban en el momento de la compilación. Significa que si un método lanza una excepción marcada, debe manejar la excepción usando el bloque try-catch o debe declarar la excepción usando la palabra clave throws, de lo contrario el programa dará un error de compilación.

Entendemos esto con la ayuda de un archivo. ejemplo:

Ejemplo de una excepción marcada

En este ejemplo estamos leyendo el archivo myfile.txt y mostrar su contenido en la pantalla. Hay tres lugares en este programa donde se lanza una excepción marcada, como se menciona en los comentarios a continuación. FileInputStream, que se utiliza para especificar la ruta y el nombre del archivo, genera FileNotFoundException. Se lanza el método read () que lee el contenido del archivo IOException y también lanza el método close () que cierra el flujo de entrada del archivo IOException.

import java.io.*;
class Example {  
   public static void main(String args[]) 
   {
	FileInputStream fis = null;
	/*This constructor FileInputStream(File filename)
	 * throws FileNotFoundException which is a checked
	 * exception
         */
        fis = new FileInputStream("B:/myfile.txt"); 
	int k; 

	/* Method read() of FileInputStream class also throws 
	 * a checked exception: IOException
         */
	while(( k = fis.read() ) != -1) 
	{ 
		System.out.print((char)k); 
	} 

	/*The method close() closes the file input stream
	 * It throws IOException*/
	fis.close(); 	
   }
}

Producción:

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
Unhandled exception type FileNotFoundException
Unhandled exception type IOException
Unhandled exception type IOException

¿Por qué este error de compilación? Como dije al principio, las excepciones marcadas se comprueban durante la compilación. Como no manejamos / declaramos las excepciones, nuestro programa dio el error de compilación.
¿Cómo corregir el error? Hay dos formas de evitar este error. Veremos ambos caminos uno a uno.

leer  Manejo de excepciones en Java con ejemplos

Método 1: declare la excepción utilizando la palabra clave throws.

Como sabemos, las tres ocurrencias de excepciones comprobadas están dentro del método main (), por lo que una forma de evitar el error de compilación es: Declarar la excepción en el método usando la palabra clave throws. Puede pensar que nuestro código está lanzando FileNotFoundException e IOException, por lo que solo declaramos IOException. La razón es que IOException es una clase principal de FileNotFoundException, por lo que de forma predeterminada la cubre. Si quieres puedes declararlos así public static void main(String args[]) throws IOException, FileNotFoundException.

import java.io.*;
class Example {  
   public static void main(String args[]) throws IOException
   {
      FileInputStream fis = null;
      fis = new FileInputStream("B:/myfile.txt"); 
      int k; 

      while(( k = fis.read() ) != -1) 
      { 
	   System.out.print((char)k); 
      } 
      fis.close(); 	
   }
}

Producción:
El contenido del archivo se muestra en la pantalla.

Método 2: manipúlelos usando bloques try-catch.

El enfoque que usamos anteriormente no es bueno en absoluto. No es la mejor práctica de manejo de excepciones. Debe proporcionar un mensaje significativo para cada tipo de excepción para que alguien pueda comprender fácilmente el error. El código debería verse así:

import java.io.*;
class Example {  
   public static void main(String args[])
   {
	FileInputStream fis = null;
	try{
	    fis = new FileInputStream("B:/myfile.txt"); 
	}catch(FileNotFoundException fnfe){
            System.out.println("The specified file is not " +
			"present at the given path");
	 }
	int k; 
	try{
	    while(( k = fis.read() ) != -1) 
	    { 
		System.out.print((char)k); 
	    } 
	    fis.close(); 
	}catch(IOException ioe){
	    System.out.println("I/O error occurred: "+ioe);
	 }
   }
}

Este código se ejecutará correctamente y mostrará el contenido del archivo.

Aquí están las otras pocas excepciones marcadas:

  • SQLException
  • IOException
  • ClassNotFoundException
  • InvocationTargetException

¿Qué son las excepciones sin marcar?

Las excepciones no marcadas no se comprueban en el momento de la compilación. Significa que si su programa está lanzando una excepción no controlada e incluso si no ha manejado / declarado esa excepción, el programa no dará un error de compilación. La mayoría de las veces, estas excepciones ocurren debido a datos incorrectos proporcionados por el usuario durante la interacción usuario-programa. Depende del programador juzgar las condiciones que pueden causar tales excepciones con anticipación y manejarlas adecuadamente. Todas las excepciones aprobadas son subclases directas de Excepción en tiempo de ejecución clase.

leer  Bloque Java Finalmente - Manejo de excepciones

Entendamos esto con un ejemplo:

Ejemplo de una excepción no seleccionada

class Example {  
   public static void main(String args[])
   {
	int num1=10;
	int num2=0;
	/*Since I'm dividing an integer with 0
	 * it should throw ArithmeticException
         */
	int res=num1/num2;
	System.out.println(res);
   }
}

Si compila este código, se compilará correctamente, pero cuando lo ejecute, se iniciará ArithmeticException. Esto muestra claramente que las excepciones no comprobadas no se comprueban en tiempo de compilación, ocurren en tiempo de ejecución. Veamos otro ejemplo.

class Example {  
   public static void main(String args[])
   {
	int arr[] ={1,2,3,4,5};
	/* My array has only 5 elements but we are trying to 
         * display the value of 8th element. It should throw
	 * ArrayIndexOutOfBoundsException
         */
	System.out.println(arr[7]);
   }
}

Este código también se habrá compilado con éxito para entonces. ArrayIndexOutOfBoundsException también es una excepción incontrolada.
Nota: Eso no significa ese compilador no está comprobando estas excepciones, por lo que no deberíamos manejarlas. De hecho, deberíamos manejarlos con más cuidado. Por ejemplo, en el ejemplo anterior debería haber un mensaje de excepción para el usuario que intenta ver un valor que no existe en la matriz para que el usuario pueda corregir el problema.

class Example {  
   public static void main(String args[]) {
	try{
	   int arr[] ={1,2,3,4,5};
	   System.out.println(arr[7]);
	}
        catch(ArrayIndexOutOfBoundsException e){
	   System.out.println("The specified index does not exist " +
		"in array. Please correct the error.");
	}
   }
}

Producción:

The specified index does not exist in array. Please correct the error.

Aquí están las pocas clases de excepción no controladas:

  • NullPointerException
  • ArrayIndexOutOfBoundsException
  • ArithmeticException
  • IllegalArgumentException
  • NumberFormatException

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *