Types d'exception

« Je voudrais te parler d'une autre chose, aujourd'hui. En Java, toutes les exceptions sont réparties en deux types : vérifiées et non vérifiées (celles qui doivent être capturées et celles qui n'ont pas à l'être). Par défaut, toutes les exceptions doivent être capturées. »

« Est-ce qu'on peut volontairement lever des exceptions dans son code ? »

« Tu peux lever n'importe quelle exception dans ton propre code. Tu peux même écrire tes propres exceptions. Mais nous reparlerons de ça plus tard. Pour l'instant, concentrons-nous sur les exceptions levées par la machine Java. »

« OK. »

« Si une exception ClassNotFoundException ou FileNotFoundException est levée (se produit) dans une méthode, le développeur doit l'indiquer dans la déclaration de la méthode. Ce sont les exceptions vérifiées. Voici à quoi cela ressemble en général : »

public static void method1() throws ClassNotFoundException, FileNotFoundException

public static void main() throws IOException

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

« Alors on écrit juste 'throws' suivi d'une liste séparée par virgules d'exceptions, c'est ça ? »

« Oui. Mais ce n'est pas tout. Pour que le programme compile, la méthode qui appelle method1 dans l'exemple ci-dessous doit effectuer une de ces deux choses : soit capturer ces exceptions soit les propager (à l'appelant), en indiquant les exceptions propagées dans sa déclaration. »

« Je reprends. Si ta méthode main doit appeler une méthode dont la déclaration continent 'throws FileNotFoundException, …', tu dois effectuer une de ces deux choses :

1) Capturer FileNotFoundException, …

Tu dois intégrer le code appelant la méthode non sûre dans un bloc try-catch.

2) Ne pas capturer FileNotFoundException, …

Dans ce cas, tu dois ajouter ces exceptions à la liste après throws de ta méthode main. »

« Pourrais-tu me donner un exemple ? »

Regarde ceci : »

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");
}

« Le code de cet exemple ne compile pas, car la méthode main appelle methode1(), qui lève des exceptions qui doivent être capturées. »

« Pour qu'il compile, tu dois ajouter la gestion des exceptions à la méthode main. Tu peux le faire d'une des deux façons suivantes : »

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");
}

« Et ici nous la capturons avec 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");
}

« Ça commence à devenir plus clair. »

« Observe l'exemple suivant. Cela t'aidera à comprendre le reste. »

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.");
    }
}

« Il existe un autre type d'exception, RuntimeException, et les classes qui en héritent. Tu n'as pas besoin de les capturer. Ce sont des exceptions non vérifiées. Elles sont considérées difficiles à prédire. Tu peux les gérer de la même façon, mais tu n'as pas besoin de les indiquer dans une clause throws. »