Différences entre la durée D'exécution / vérifiée/non vérifiée/erreur / Exception

depuis que je suis un nouveau développeur Java, j'ai aussi eu des difficultés à distinguer et à traiter les différents types d'exceptions. C'est pourquoi j'ai pris une courte note sur ce sujet, et chaque fois que je suis confus je passe par là. Ici, il est avec l'image de l' Throwable hiérarchie des classes:

[image courtoisie de JavaTpoint].

Il y a trois classes clés à retenir ici: Throwable,Exception et Error. Parmi ces classes Exception peut être divisé en deux types: "coché Exception" et "unchecked Exception".

Coché Exception:

• ce sont les classes qui étendent Throwable sauf RuntimeException et Error.
• ils sont aussi connus sous le nom d'exceptions de compilation time parce qu'ils sont vérifiés au moment de la compilation, ce qui signifie que le compilateur nous force à les traiter avec try/catch ou indiquer dans la signature de la fonction que throws nous forcer à traiter avec eux dans l'interlocuteur.
• il s'agit de problèmes programmatiques récupérables qui sont causés par des conditions inattendues échappant au contrôle du code (par exemple, mise bas de la base de données, erreur d'E/S du fichier, mauvaise entrée, etc.).
• Exemple:IOException,SQLException, etc.

Exception Non Vérifiée:

• les classes qui s'étendent RuntimeException sont connus comme non contrôlés exception.
• les exceptions non vérifiées ne sont pas vérifiées lors de la compilation, mais lors de l'exécution, d'où le nom.
• ce sont aussi des problèmes programmatiques récupérables mais pas coché exception ils sont causés par des défauts dans le flux ou la configuration du code.
• Exemple:ArithmeticException,NullPointerException,ArrayIndexOutOfBoundsException, etc.
• Puisqu'il s'agit d'erreurs de programmation, elles peuvent être évitées en codant gentiment/sagement. Exemple "division par zéro" produit un ArithmeticException, ce qui peut être évité par une simple vérification du diviseur. De même, nous pouvons éviter NullPointerException en vérifiant simplement les références:if (object != null) ou même en utilisant meilleures techniques.

Erreur:

• Error renvoie à une situation irrécupérable qui n'est pas gérée par un try/catch.
• Exemple:OutOfMemoryError,VirtualMachineError,AssertionError, etc.

pourquoi autant de types?

Stephen C's réponse que je veux dire: la gestion des exceptions est une opération relativement coûteuse en Java. nous ne devrions pas mettre toute situation exceptionnelle dans un try/catch bloc. Utilisation Excessive de la try/catch s peut nuire au rendement du programme.

En conclusion, Exception s doit être manipulé par programmation autant que possible. Sur l'autre la main, nous ne pouvons pas traiter Error s, donc ce pourrait être quelques raisons logiques pour lesquelles il existe de nombreux types d'exceptions.

réponse de TofuBeer explique clairement ce que les classes d'exception signifient.

pourquoi tous ces types? Au lieu de cela, Java peut simplement suivre une conception simple(juste essayer/attraper tous les types) pour gérer une condition anormale dans un programme?

Pourquoi? Parce qu'ils sont nécessaires! Sans ces quatre catégories, il ne serait pas pratique de traiter les exceptions par grande catégorie.

• comment capteriez-vous "toutes les erreurs JVM fatales" sans la Error classe?
• Comment attraper "toutes les exceptions qui ne sont pas des erreurs fatales JVM" sans le Exception classe?
• Comment attraper "toutes les exceptions non vérifiées" sans le RuntimeException classe?

les Exceptions Runtime vous offrent la flexibilité d'éviter la capture, la déclaration des exceptions.

• erreur (Lancers par VM, ne doit pas être attrapé ou manipulé)
  1. erreur VM
  2. Erreur D'Assertion
  3. erreur de Linkage ...so on
• Runtime / Uncheck Exception (erreur de programmation, ne doit pas être attrapé ou manipulé)
  1. NullPointerException
  2. ArrayIndexOutOfBoundException
  3. Illégalargumentexception ... ainsi de suite
• Vérifier l'Exception de toute Autre Chose, les Applications sont devrait être pris ou manipulé)
  1. IOException
  2. FileNotFoundException
  3. SQLException ...etc

différence entre les exceptions vérifiées et non vérifiées:

nous avons beaucoup de différences entre l'exception contrôlée et l'exception non contrôlée mais toutes les différences proviennent d'une seule considération de base que si le l'exception peut être résolue par compilateur ou non.

les Points à retenir sont:

[1] coché exception signifie compilateur vérifié Exceptions. Cela signifie que le compilateur exige qu'une telle exception soit traitée par le bloc try-catch ou lance des mots clés.

[2] les exceptions non vérifiées sont celles pour lesquelles le compilateur ne fournit aucun mandat comme ils peuvent être résolus par le développeur en codant/programmant comme le flux de contrôle est contrôlable comme dans ArithmeticException, NullPointerException ArrayIndexOutOfBoundsException, IllegalArgumentException ,etc.

je m'appelle "Exception-Identité-Test" où vous prenez n'importe quelle exception aléatoire de java doc et posez lui juste une question. "Hé Exception! Pouvez-vous être résolu par programmation?"

si l'exception dit Oui il s'agit alors d'une Exception non contrôlée car elle peut être résolue par un changement de code ou par la résolution d'une erreur de calcul, etc.

d'un autre côté si L'Exception dit Aucun alors ceci est coché Exception car dans coché le flux de contrôle D'Exception sort de notre code comme si quelqu'un change les mots de passe de la base de données ou quelqu'un débranche le câble réseau ,connection timeout (ConnectException), certaines ressources ne sont pas trouvées (FileNotFoundException, ClassNotFound), SQLException, InvocatonTargetException etc. Ceux-ci ne peuvent pas être résolus en programmant