Tipos de excepción

"Quería hablar de una cosa más hoy. En Java, todas las excepciones se dividen en dos tipos: marcadas y no marcadas (aquellas que se deben capturar y aquellas que no es necesario capturar). De forma predeterminada, todas las excepciones deben ser atrapó."

"¿Puedes lanzar excepciones intencionalmente en tu código?"

"Puede lanzar cualquier excepción en su propio código. Incluso puede escribir sus propias excepciones. Pero hablaremos de eso más adelante. En este momento, concentrémonos en las excepciones lanzadas por la máquina Java".

"DE ACUERDO."

"Si ClassNotFoundException o FileNotFoundException se lanzan (ocurren) en un método, el desarrollador debe indicarlas en la declaración del método. Estas son excepciones verificadas . Así es como se ve normalmente:"

public static void method1() throws ClassNotFoundException, FileNotFoundException

public static void main() throws IOException

public static void main() // Doesn't throw any exceptions

"Así que solo escribimos 'lanzamientos' seguidos de una lista de excepciones delimitada por comas, ¿verdad?"

"Sí. Pero hay más. Para que el programa compile, el método que llama method1en el ejemplo a continuación debe hacer una de dos cosas: capturar estas excepciones o volver a lanzarlas (a la persona que llama) , indicando las excepciones lanzadas nuevamente en su declaración " .

"Otra vez. Si su método principal necesita llamar a un método cuya declaración contiene ' lanza FileNotFoundException ,...', entonces debe hacer una de estas dos cosas:

1) Captura la excepción FileNotFoundException , …

Debe envolver el código que llama al método inseguro en un bloque try-catch .

2) No atrape FileNotFoundException , …

Debe agregar estas excepciones a la lista de lanzamientos de su método principal ".

"¿Podrías darme un ejemplo?"

"Mira esto:"

public static void main(String[] args)
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"El código de este ejemplo no se compilará porque el método principal llama a method1() , que arroja excepciones que deben detectarse".

"Para compilarlo, debemos agregar el manejo de excepciones al método principal. Puede hacerlo de dos maneras:"

public static void main(String[] args)  throws FileNotFoundException, ClassNotFoundException 
{
    method1();
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"Y aquí lo atrapamos con un try-catch :"

public static void main(String[] args)
{
    try
    {
        method1();
    }
    catch(Exception e)
    {
    }
}

public static void method1() throws FileNotFoundException, ClassNotFoundException
{
    //Throws FileNotFoundException if the file doesn't exist
    FileInputStream fis = new FileInputStream("C2:\badFileName.txt");
}

"Está empezando a aclararse".

"Mira el siguiente ejemplo. Te ayudará a entender el resto".

public static void method2() throws FileNotFoundException, ClassNotFoundException
{
    method1();
}

public static void method3() throws ClassNotFoundException
{
   try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
}

public static void method4()
{
    try
    {
        method1();
    }
    catch (FileNotFoundException e)
    {
        System.out.println("FileNotFoundException has been caught.");
    }
    catch (ClassNotFoundException e)
    {
        System.out.println("ClassNotFoundException has been caught.");
    }
}

"Hay un tipo más de excepción, RuntimeException y las clases que la heredan. No es necesario que las atrape. Estas son excepciones no verificadas. Se consideran difíciles de predecir. Puede tratarlas de la misma manera, pero no es necesario indicarlos en una cláusula de tiros".