web-dev-qa-db-fra.com

Pourquoi "Exceptions de lancers" est-il nécessaire lors de l'appel d'une fonction?

class throwseg1
{
    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 s[]) throws Exception  // Why throws is necessary here ?
    {
        throwseg1 o1 = new throwseg1();
        o1.show3();
    }
}

Pourquoi le compilateur indique que les méthodes show2(), show3() et main() ont 

exception non déclarée Exception qui doit être interceptée ou déclarée comme lancée

quand je supprime throws Exception de ces méthodes? 

javaexception-handlingunhandled-exceptionthrowschecked-exceptions
70
nr5

Comme vous le savez peut-être, en Java, les exceptions peuvent être classées en deux catégories: une qui nécessite la clause throws ou qui doit être gérée si vous n'en spécifiez pas une autre. Maintenant, voyez la figure suivante:

enter image description here

En Java, vous pouvez lancer tout ce qui étend la classe Throwable. Cependant, vous n'avez pas besoin de spécifier une clause throws pour toutes les classes. Plus précisément, les classes qui sont soit une Error ou une RuntimeException ou l'une des sous-classes de ces deux. Dans votre cas, Exception n'est pas une sous-classe de Error ou RuntimeException. Il s’agit donc d’une exception vérifiée qui doit être spécifiée dans la clause throws si vous ne gérez pas cette exception particulière. C'est pourquoi vous aviez besoin de la clause throws.

De Tutoriel Java :

Une exception est un événement qui se produit pendant l'exécution d'un programme et qui perturbe le flux normal des instructions du programme.

Maintenant, comme vous le savez, les exceptions sont classées en deux: cochées et non cochées. Pourquoi ces classifications?

Checked Exception: Ils sont utilisés pour représenter des problèmes pouvant être résolus pendant l'exécution du programme. Ils ne sont généralement pas la faute du programmeur. Par exemple, un fichier spécifié par l'utilisateur n'est pas lisible, ou aucune connexion réseau disponible, etc., Dans tous ces cas, notre programme n'a pas besoin de se fermer. mécanisme (comme le travail hors connexion lorsque le réseau n'est pas disponible), etc.

Exceptions non contrôlées: Elles peuvent à nouveau être divisées en deux: Erreurs et Exceptions Runtime. Une des raisons pour lesquelles ils ne sont pas contrôlés est qu’ils sont nombreux et qu’ils sont obligés de tous les gérer, cela encombrera notre programme et réduira sa clarté. L'autre raison est:

  • Exceptions d'exécution: Elles surviennent généralement à cause d'une faute des programmeurs. Par exemple, si une ArithmeticException de division par zéro se produit ou si une ArrayIndexOutOfBoundsException se produit, c'est parce que nous ne sommes pas assez prudents dans notre codage. Ils se produisent généralement à cause d’erreurs dans la logique de notre programme. Ils doivent donc être effacés avant que notre programme ne passe en mode de production. Ils ne sont pas contrôlés en ce sens que notre programme doit échouer lorsqu'il se produit, afin que nous, programmeurs, puissions le résoudre au moment du développement et du test.

  • Erreurs: Les erreurs sont des situations dans lesquelles le programme ne peut généralement pas récupérer. Par exemple, si une StackOverflowError se produit, notre programme ne peut pas faire grand chose, comme augmenter la taille de la pile d'appel de fonction du programme. Ou si une OutOfMemoryError se produit, nous ne pouvons pas grand-chose pour augmenter la quantité de RAM disponible pour notre programme. Dans de tels cas, il est préférable de quitter le programme. C'est pourquoi ils sont faits sans contrôle.

Pour des informations détaillées, voir: 

121
Jomoos

Java nécessite que vous gériez ou déclariez toutes les exceptions. Si vous ne gérez pas une exception à l'aide d'un bloc try/catch, vous devez la déclarer 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.

22
jebar8

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

3
Taymon

La déclaration throws Exception est un moyen automatisé de garder une trace des méthodes qui peuvent générer 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 façon inattendue et rapporte une exception pour une raison que nous n’avions pas anticipée avant d’exécuter le programme, comme une division par zéro ou un index hors limites. Étant donné que la méthode n'attendait pas d'erreurs, elles ne pouvaient pas être "interceptées" et traitées avec une clause try catch. Les utilisateurs peu méfiants de la méthode ne le sauraient pas non plus et leurs programmes cesseraient également.

Lorsque le programmeur sait que certains types d'erreurs peuvent se produire mais qu'il souhaite gérer ces exceptions en dehors de la méthode, la méthode peut "jeter" 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 (pouvait) générer 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 le connaître, attraper et gérer toutes les exceptions que la méthode peut générer. Étant donné que les programmes peuvent avoir plusieurs couches de méthodes écrites par différents programmes, il devient difficile (impossible) de savoir quelles méthodes peuvent générer des exceptions. 

Même si Java a la capacité de déclarer des exceptions, vous pouvez toujours écrire une nouvelle méthode avec des exceptions non gérées et non déclarées. Java la compilera et vous pourrez l'exécuter en espérant qu'elle sera meilleure. Ce que Java ne vous laissera pas faire, c’est de compiler votre nouvelle méthode s’il utilise une méthode déclarée en tant qu’exception (s) exceptionnelle (s), sauf si vous gérez les exceptions déclarées dans votre méthode ou déclarez que votre méthode lève la même exception (s) ou s’il existe plusieurs exceptions, vous pouvez en gérer certaines et jeter le reste. 

Lorsqu'un programmeur déclare que la méthode lève un type d'exception spécifique, il s'agit simplement d'un moyen automatisé d'avertir les autres programmeurs utilisant cette méthode qu'une exception est possible. Le programmeur peut alors décider de gérer l'exception ou transmettre l'avertissement en déclarant que la méthode d'appel génère également la même exception. Puisque 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 que l'un ou l'autre se produit.

La bonne chose à propos de ce type de solution est que lorsque le compilateur rapporte Error: Unhandled exception type Java.io.IOException, il donne le fichier et le numéro de ligne de la méthode déclarée pour lever l’exception. Vous pouvez ensuite choisir de simplement passer le dollar et déclarer votre méthode aussi "lève IOException". Cela peut être fait jusqu’à la méthode principale, puis le programme s’arrête et signale l’exception à l’utilisateur. Cependant, il est préférable de détecter l’exception et de la traiter de manière agréable, par exemple en expliquant à l’utilisateur ce qui est arrivé et comment y remédier. Quand une méthode attrape et gère l'exception, il n'est plus nécessaire de déclarer l'exception. La responsabilité s'arrête là pour ainsi dire.

3
dansalmo
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());
   }
}

Seuls de petits changements dans votre programme. Ce qui 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, mais pas nécessairement au même endroit (par exemple, la méthode show1,2,3 dans votre programme), mais vous devez utiliser la méthode la plus proche à l'intérieur de la «principale». dans un mot, il y a 'lancer', il doit y avoir 'attraper/essayer', même si ce n'est pas la même méthode où une exception se produit.

0
tawess

Si vous propagez l'exception en déclarant la directive throws dans la signature de la méthode actuelle, vous devez utiliser une construction try/catch quelque part dans la ligne ou la pile d'appels pour gérer l'exception.

0
Beaumont Muni
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 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 le gérer ici. Si vous ne gérez pas l'exception ici, vous utilisez le mot clé throws . C'est pourquoi vous utilisez le mot clé throws au niveau de la signature de la méthode.

0
Aditya