Que se passe-t-il si une méthode lève une exception qui n'a pas été spécifiée dans la déclaration de méthode avec «throws»

StackOverflow https://stackoverflow.com/questions/4889711

  •  28-10-2019
  •  | 
  •  

Question

Je n'ai jamais utilisé la clause "throws", et aujourd'hui un compagnon m'a dit que je devais spécifier dans la déclaration de méthode quelles exceptions la méthode peut lancer.Cependant, j'ai utilisé des exceptions sans problème sans le faire, alors pourquoi est-ce nécessaire si, en fait, c'est nécessaire?

Était-ce utile?

La solution

Java propose deux types d'exceptions: les exceptions cochées et les exceptions non cochées .

Les exceptions non cochées sont des sous-classes de RuntimeException et vous n'avez pas besoin d'ajouter une déclaration throws.Toutes les autres exceptions doivent être gérées dans le corps de la méthode, soit avec une instruction try / catch, soit avec une déclaration throws.

Exemple d'exceptions non vérifiées: IllegalArgumentException qui est parfois utilisé pour notifier qu'une méthode a été appelée avec des arguments illégaux.Aucun lancer nécessaire.

Exemple d'exceptions vérifiées: IOException que certaines méthodes du paquet java.io peuvent lancer.Utilisez un try / catch ou ajoutez throws IOException à la déclaration de méthode et déléguez la gestion des exceptions à l'appelant de la méthode.

Autres conseils

Si une méthode est déclarée avec le mot-clé throws, toute autre méthode qui souhaite appeler cette méthode doit soit être prête à l'attraper, soit déclarer qu'elle lèvera elle-même une exception.

Par exemple, si vous souhaitez suspendre l'application, vous devez appeler Thread.sleep(milliseconds);

Mais la déclaration de cette méthode indique qu'elle lancera un InterruptedException 

public static void sleep(long millis) throws InterruptedException

Donc, si vous souhaitez l'appeler par exemple dans votre méthode principale, vous devez soit l'attraper: 

public static void main(String args[]) {
    try {
        Thread.sleep(1000);
    } catch(InterruptedException ie) {
        System.out.println("Opps!");
    }
}

Ou faites en sorte que la méthode déclare également qu'elle lève une exception: 

public static void main(String args[]) throws InterruptedException {
    Thread.sleep(1000);
}

Cela peut arriver, même avec des exceptions cochées .Et parfois, cela peut interrompre la journalisation.

Supposons qu'une méthode de bibliothèque utilise cette astuce pour permettre une implémentation de Runnable qui peut lancer IOException: 

class SneakyThrowTask implements Runnable {

    public void run() {
        throwSneakily(new IOException());
    }

    private static RuntimeException throwSneakily(Throwable ex) {
        return unsafeCastAndRethrow(ex);
    }

    @SuppressWarnings("unchecked")
    private static <X extends Throwable>X unsafeCastAndRethrow(Throwable ex) throws X {
        throw (X) ex;
    }

}

Et vous l'appelez comme ceci: 

public static void main(String[] args) {
    try {
        new SneakyThrowTask().run();
    } catch (RuntimeException ex) {
        LOGGER.log(ex);
    }
}

L'exception ne sera jamais enregistrée.Et comme il s'agit d'une exception cochée, vous ne pouvez pas écrire ceci: 

public static void main(String[] args) {
    try {
        new SneakyThrowTask().run();
    } catch (RuntimeException ex) {
        LOGGER.log(ex);
    } catch (IOException ex) {
        LOGGER.log(ex); // Error: unreachable code
    }
}
  1. Vous devez déclarer les exceptions vérifiées que votre méthode lève.
  2. Si vous déclarez "throws Exception" qui couvre à peu près la plupart sinon toutes les exceptions vérifiées
  3. Vous pouvez toujours lever une exception d'exécution non vérifiée sans avoir à déclarer.

Je suis presque sûr que si vous essayez de lancer une exception vérifiée et que vous n'avez pas déclaré la méthode comme lançant ce type, le code ne se compilera même pas (en vérifiant maintenant).

MODIFIEZ, d'accord si vous essayez quelque chose de simple comme 

public static void main(String[] args) {
   throw new Exception("bad");
}

vous obtenez une erreur de compilation.

Plus précisément pour votre question, si vous invoquez une méthode déclarée pour lever des exceptions, vous devez soit essayer / intercepter l'invocation de méthode, soit déclarer que votre méthode lève les exceptions.

Le mot-clé throws est utilisé pour lancer une exception à une autre méthode.

Cela facilite l'exception de poignée pour l'utilisateur.Parce qu'alors toutes les exceptions peuvent être gérées dans une méthode qui est utilisée pour s'exécuter.

Il s'agit principalement d'une méthode, de sorte que l'utilisateur n'a pas besoin d'explorer l'intérieur de la méthode.

Il lance également une force mot-clé au compilateur pour gérer l'exception qui pourrait se produire.

Si vous étiez un développeur d'API, lorsque vous écrivez un code, vous pourriez voir qu'une exception pourrait se produire, vous utilisez donc le mot clé throws pour le gérer lorsque la méthode s'exécute.

Java jette un mot-clé,

  • Le mot clé Java throws est utilisé pour déclarer une exception.
  • throws est suivi de class.
  • L'exception vérifiée peut être propagée avec throws.
  • Il fournit des informations à l'appelant de la méthode sur l'exception.

exemple de throws, 

void m()throws ArithmeticException{  
    //method code  
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top