jette des exceptions en Java

Question

quand vous faites ceci:

public class Blah { 

    public void doBlah() throws BlahException { 

    } 

} 

Qu'est-throws BlahException vraiment l'ajout faire? Regroupe-t-il fondamentalement toute exception à celle-ci?

c'est-à-dire s'il y a une exception, quelle qu'elle soit, sera toujours lancée en utilisant BlahException?

Answer 1

Il indique aux clients de votre classe que la méthode DoBlah peut déclencher une exception BlahException ou toute autre exception qui l'étend.

S'il s'agit d'une exception vérifiée, le compilateur exige que les appels à cette méthode soient renvoyés dans un bloc try/catch. Si elle n'est pas cochée, ils peuvent choisir de ne pas intercepter l'exception, mais ils doivent être conscients que s'ils ne le font pas, ils seront placés plus haut dans la pile d'appels.

Il ne dit rien sur les exceptions non contrôlées comme NullPointException ou les erreurs. Ceux-ci peuvent toujours être jetés aussi bien. Ils ne sont pas requis dans la clause throws.

Ce code montre comment cela fonctionne:

ExceptionDemo.java:

package exceptions; 

public class ExceptionDemo 
{ 
    public static void main(String[] args) 
    { 
     ExceptionDemo demo = new ExceptionDemo(); 

     try 
     { 
      // Removing the try/catch will result in a compilation error 
      demo.doChecked();    
     } 
     catch (CheckedException e) 
     { 
      e.printStackTrace(); 
     } 

     // Note: Not inside a try/catch, in spite of the throws clause 
     demo.doUnchecked(); 
    } 

    public void doChecked() throws CheckedException 
    { 
     System.out.println("doing something that may throw a checked exception"); 
    } 

    // Note: "throws" clause is unnecessary for an unchecked exception 
    public void doUnchecked() throws UncheckedException 
    { 
     System.out.println("doing something that may throw an unchecked exception"); 
    } 
} 

CheckedException.java:

package exceptions; 

public class CheckedException extends Exception 
{ 
    public CheckedException() 
    { 
     super(); 
    } 

    public CheckedException(String message) 
    { 
     super(message); 
    } 

    public CheckedException(String message, Throwable cause) 
    { 
     super(message, cause); 
    } 

    public CheckedException(Throwable cause) 
    { 
     super(cause); 
    } 
} 

UncheckedException.java:

package exceptions; 

public class UncheckedException extends RuntimeException 
{ 
    public UncheckedException() 
    { 
     super(); 
    } 

    public UncheckedException(String message) 
    { 
     super(message); 
    } 

    public UncheckedException(String message, Throwable cause) 
    { 
     super(message, cause); 
    } 

    public UncheckedException(Throwable cause) 
    { 
     super(cause); 
    } 
} 

Answer 2

No. leLa clauseindique au compilateur que votre fonction pourrait lancer une BlahException et que cela devrait être intercepté par l'appelant. Par exemple:

class ExceptionThrower 
{ 
    void someFunction() 
    { 
     for(int i =0; i<10;i++) 
      if(i==4) throw new Exception(); 
    } 

    public static void main(String args[]) 
    { 
     new ExceptionThrower().someFunction(); 
    } 
} 

Ce programme ne compile pas, car il peut lancer une exception de type Exception, et l'exception n'a été ni pris, ni déclaré être jeté.

Cependant, le code suivant sera compilé correctement.

class ExceptionThrower 
{ 
    void someFunction() throws Exception 
    { 
     for(int i =0; i<10;i++) 
      if(i==4) throw new Exception(); 
    } 

    public static void main(String args[]) 
    { 
     try 
     { 
      new ExceptionThrower().someFunction(); 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 

    } 
} 

Essentiellement, vous dites au compilateur que cette fonction peut jeter une exception non gérée dans la fonction elle-même. Ces types d'exceptions sont toutes des sous-classes de java.lang.Exception et sont appelées exceptions vérifiées. D'autres exceptions qui indiquent une défaillance catastrophique causée par des bogues dans le programme lui-même, plutôt que par une condition telle qu'une entrée mal formée sont des sous-classes de java.lang.RuntimeException et sont appelées exceptions non contrôlées. En résumé, des exceptions non contrôlées peuvent être levées sans clause throws dans la signature de la méthode, alors que toute exception vérifiée doit y être indiquée.

Pour une discussion des exceptions non vérifiées et vérifiés par rapport à voir http://www.javapractices.com/topic/TopicAction.do?Id=129

Answer 3

Votre méthode doBlah() besoin d'avoir quelque chose qui peut throwBlahException ou d'une sous-classe de BlahException.Cela dit à l'appelant de doBlah() de faire attention en général à envelopper le code dans try-catch.

Answer 4

L'idée générale est que sans mot clé throws, l'exception déclenchée par la méthode ne peut pas être gérée en dehors de la méthode.

N'est-ce pas?