Pourquoi "throws Exception" nécessaire lors de l'appel d'une fonction?

Java nécessite de gérer ou de déclarer toutes les exceptions. Si vous ne gérez pas une exception à l'aide d'un bloc try/catch, elle doit être déclarée dans la signature de la méthode.

Par exemple:

class throwseg1 {
    void show() throws Exception {
        throw new Exception();
    }
}

Devrait être écrit comme:

class throwseg1 {
    void show() {
        try {
            throw new Exception();
        } catch(Exception e) {
            // code to handle the exception
        }
    }
}

De cette façon, vous pouvez vous débarrasser de la déclaration "throws Exception" dans la déclaration de méthode.

Exception est une classe d'exception vérifiée. Par conséquent, tout code qui appelle une méthode qui déclare qu'elle throws Exception doit la gérer ou la déclarer.

La déclaration throws Exception est un moyen automatisé de suivre les méthodes qui pourraient déclencher une exception pour des raisons anticipées mais inévitables. La déclaration est généralement spécifique au type ou aux types d'exceptions pouvant être levées, telles que throws IOException ou throws IOException, MyException.

Nous avons tous ou finirons par écrire du code qui s'arrête de manière inattendue et signale une exception due à quelque chose que nous n'avions pas anticipé avant d'exécuter le programme, comme la division par zéro ou l'index hors limites. Depuis le les erreurs n'étaient pas attendues par la méthode, elles ne pouvaient pas être "capturées" et traitées avec une clause try catch. Tous les utilisateurs sans méfiance de la méthode ne seraient pas non plus au courant de cette possibilité et leurs programmes s'arrêteraient également.

Lorsque le programmeur sait que certains types d'erreurs peuvent se produire mais souhaite gérer ces exceptions en dehors de la méthode, la méthode peut "lancer" un ou plusieurs types d'exceptions à la méthode appelante au lieu de les gérer. Si le programmeur n'a pas déclaré que la méthode (pourrait) lancer une exception (ou si Java n'avait pas la capacité de la déclarer), le compilateur ne pouvait pas le savoir et il appartiendrait au futur utilisateur de la méthode de connaître, d'attraper et de gérer toutes les exceptions que la méthode pourrait lancer. Étant donné que les programmes peuvent avoir de nombreuses couches de méthodes écrites par de nombreux programmes différents, il devient difficile (impossible) de garder une trace des méthodes susceptibles de générer des exceptions.

Même si Java a la capacité de déclarer des exceptions, vous pouvez toujours écrivez une nouvelle méthode avec des exceptions non gérées et non déclarées, et Java la compilera et vous pourrez l'exécuter et espérer le meilleur. Ce que Java ne vous laissera pas faire, c'est compiler votre nouvelle méthode si elle utilise une méthode qui a été déclarée comme jetant des exceptions, sauf si vous gérez les exceptions déclarées dans votre méthode ou déclarez votre méthode comme jetant les mêmes exceptions ou s'il y a plusieurs exceptions, vous pouvez gérer certaines et lancer le reste.

Lorsqu'un programmeur déclare que la méthode lève un type spécifique d'exception, c'est juste un moyen automatisé d'avertir les autres programmeurs utilisant la méthode qu'une exception est possible. Le programmeur peut alors décider de gérer l'exception ou de transmettre l'avertissement en déclarant que la méthode appelante lance également la même exception. Comme le compilateur a été averti que l'exception est possible dans cette nouvelle méthode, il peut automatiquement vérifier si les futurs appelants de la nouvelle méthode gèrent l'exception ou la déclarent et l'appliquent l'un ou l'autre à se produire.

La bonne chose à propos de ce type de solution est que lorsque le compilateur signale Error: Unhandled exception type java.io.IOException il donne le numéro de fichier et de ligne de la méthode déclarée pour lever l'exception. Vous pouvez ensuite choisir de simplement passer le buck et déclarer votre méthode également "jette IOException". Cela peut être fait jusqu'à la méthode principale où cela provoquerait alors l'arrêt du programme et signalerait l'exception à l'utilisateur. Cependant, il est préférable d'attraper l'exception et de traiter avec dans une jolie manière d'expliquer à l'utilisateur ce qui s'est passé et comment le résoudre. Lorsqu'une méthode attrape et gère l'exception, elle n'a plus à déclarer l'exception. Le mâle s'arrête là pour ainsi dire.

package javaexception;


public class JavaException {
   void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

void show2() throws Exception  // Why throws is necessary here ?
{
    show();
}

void show3() throws Exception  // Why throws is necessary here ?
{
    show2();
}
public static void main(String[] args) {

   JavaException a = new JavaException();

   try{
   a.show3();
   }catch(Exception e){
       System.out.println(e.getMessage());
   }
}

Seulement de petits changements dans votre programme. Ce qu'il semble être mal compris par beaucoup en ce qui concerne le problème principal, c'est que chaque fois que vous lancez une exception, vous devez la gérer, pas nécessaire au même endroit ( ex. show1, 2, 3 méthode dans votre programme) mais vous devez d'abord appeler la méthode à l'intérieur du 'main'. en un mot, il est "jeter", il faut " attraper/essayez, même si ce n'même méthode lorsqu'une exception se produit.

void show() throws Exception
{
    throw new Exception("my.own.Exception");
}

Comme il y a une exception vérifiée dans la méthode show (), qui n'est pas gérée dans cette méthode, nous utilisons donc le mot clé throws pour propager l'exception.

void show2() throws Exception //Why throws is necessary here ?
{
show();
}

Puisque vous utilisez la méthode show() dans la méthode show2() et que vous avez propagé l'exception au moins, vous devriez gérer ici. Si vous ne gérez pas l'exception ici, vous utilisez le mot clé throws. C'est donc la raison de l'utilisation du mot clé throws à la signature de la méthode.