Qu'est-ce qu'une exception dans java?

Question

Je Haveâ quelques questions concernant les exceptions en java:

1. Qu'est-ce exception java?

2. Une exception est-elle considérée comme une erreur?

3. Quand dois-je lancer des exceptions?

4. Combien de types d'exceptions?

Answer 1

1. Un signal que quelque chose a échoué dans le code, mais qui est récupérable par programme.

2. Dépend de la façon dont vous interprétez "erreur". C'est ambigu.

3. Lorsque vous voulez signaler que quelque chose a échoué dans le code, mais qui est récupérable par programme.

4. Un nombre incalculable. Vous pouvez également créer des personnalisées.

Pour en savoir plus sur les exceptions, consultez la section Sun tutorial on the subject.

Answer 2

Vous pouvez commencer ici:

http://java.sun.com/docs/books/tutorial/essential/exceptions/

Answer 3

1. Une exception est une erreur récupérable dans votre application.

2. C'est par rapport à ce que vous faites et à ce que l'utilisateur attend. Disons que vous avez une division par 0 exception, et votre application est une calculatrice. La plupart des utilisateurs s'attendent à ce qu'un message apparaisse expliquant qu'ils ont divisé par 0.

3. Vous devriez lancer des exceptions quand vous le souhaitez. Vous pouvez faire une application qui ne fait rien d'exceptionnel. Comme un traitement de texte génial qui lance des exceptions chaque fois que vous appuyez sur une touche, mais quand il attrape l'exception, il sort le caractère que vous venez de taper. En outre, vous pouvez faire un jeu génial de connecter quatre, où chaque fois que vous gagnez, il lance une exception.

4. Il existe plusieurs types d'exceptions. Une exception généré par l'utilisateur (par la commande "throw"), une exception du système (exemple de diviser par 0), etc., etc.

Answer 4

Quelle est exception java?

C'est une classe utilisée pour identifier un comportement inattendu dans votre application.

Une exception est-elle considérée comme une erreur?

Pas toujours (et dépend de ce que vous appelez une erreur)

Quand dois-je lancer des exceptions?

Lorsque votre application est dans un état inattendu ou yo voulez signaler un comportement inattendu

Combien genre d'exceptions?

Il y a trois:

• exceptions cochés (doivent être traitées par exemple FileNotFoundException)

Ces exceptions ne sont pas imputables au programmeur, mais pour l'environnement, il court dans et le programmeur peut faire quelque chose à ce sujet (le programmeur peut le gérer)

• Runtime exceptio ns (a.k.a. GoodProgrammerExpected ^tm, ne devrait pas être traitée, à savoir NullPointerException)

Ces exceptions sont les défauts de programmeur et origine par les mauvaises pratiques de codage (ou connaissances) et peuvent toujours être évités, par exemple ne pas vérifier les limites des tableaux.

• erreurs (c.-à-OutOfMemoryError, devraient pas être manipulés)

Ces exceptions ne sont pas imputables au programmeur, mais pour l'environnement, il se heurte, ils diffèrent de l'exception vérifiée dans le fait , le programmeur ne peut rien y faire. Par exemple, si le système manque de mémoire,

Voir this answer pour une explication plus détaillée.

Answer 5

Par ailleurs, vous pouvez également créer vos propres exceptions ... par exemple:

Answer 6

Une exception Java est un mécanisme pour interrompre le déroulement normal du programme, le plus souvent - mais pas nécessairement - - lorsqu'une erreur empêche la poursuite du traitement. Les exceptions sont les plus utiles pour "Panic Abort Eject !!" conditions.

Souvent, lorsque vous écrivez un programme, vous rencontrez une condition où il est impossible de continuer. Il y a souvent beaucoup de telles conditions possibles dans un programme. Par exemple, supposons que vous lisez un fichier censé contenir une liste de noms et d'adresses. Vous pouvez découvrir que vous ne pouvez pas trouver le fichier sur le disque dur. Le format peut ne pas correspondre à ce que vous attendez. Il peut y avoir des entrées en double. Etc. Certaines de ces erreurs peuvent rendre impossible l'opération du tout, comme "fichier non trouvé". Dans d'autres cas, vous devrez peut-être abandonner un enregistrement mais continuer à traiter les enregistrements restants dans le fichier.

Avant que des exceptions soient inventées, les programmeurs se retrouvaient souvent avec des IFs profondément imbriqués pour toutes les erreurs possibles.Comme (certains pseudo-code, aucune langue particulière):

fileHandle=open("myfile.txt"); 
if (fileHandle==null) 
{ 
    writeMessage("File not found"); 
} 
else 
{ 
    while (record=fileHandle.read()) 
    { 
    parseRecord(record); 
    if (parseError) 
    { 
     writeMessage("Invalid record format"); 
    } 
    else 
    { 
     lookupRecord(record); 
     if (found) 
     { 
     writeMessage("Duplicate record"); 
     } 
     else 
     { 
     ... etc ... 
     } 
    } 
    } 
} 

Cela pourrait être très déroutant, car le nombre de conditions d'erreur augmente. Les exceptions nous permettent de renflouer à tout moment sans avoir besoin d'un tas de clauses «else».

De plus, nous avons souvent des fonctions qui appellent d'autres fonctions qui appellent d'autres fonctions, etc., ou des boucles dans une boucle à l'intérieur des boucles. Certaines erreurs peuvent être traitées au plus profond de la structure. Principalement, cela signifie que nous pouvons traiter et récupérer, comme un mauvais dossier. D'autres devraient être manipulés à un niveau supérieur. Principalement cela signifie ceux où tout ce que nous pouvons faire est d'abandonner le processus et d'afficher un message d'erreur pour l'utilisateur ou écrire l'erreur dans un fichier journal ou autre. Les exceptions permettent de le faire en définissant un niveau auquel nous détectons l'erreur. Nous pouvons mettre le bloc "catch" immédiatement après la déclaration qui pourrait créer l'erreur et prendre des mesures correctives. Nous pouvons le mettre un peu plus haut pour interrompre le traitement d'un enregistrement, par exemple, mais continuer avec le prochain enregistrement. Ou nous pouvons le mettre en haut pour annuler le tout. Pour prendre l'exemple ci-dessus:

try 
{ 
    fileHandle=open("myfile.txt"); 
    if (fileHandle==null) 
    throw new FileException("File not found") 
while (record=fileHandle.read()) 
{ 
    try 
    { 
    parseRecord(record); 
    if (parseError) 
     throw new RecordException("Invalid format") 
    lookupRecord(record); 
     throw new RecordException("Duplicate record") 
    ... etc ... 
    } 
    catch (RecordException e) 
    { 
    showMessage(e.getMessage()) 
    } 
} 
catch (FileException e) 
{ 
    showMessage(e.getMessage()) 
} 

Notez qu'une exception RecordException annulera le traitement de l'enregistrement, mais passons au suivant. Une FileException abat le tout.

Un troisième avantage des exceptions est qu'elles aident à identifier clairement les conditions d'exception.

Eh bien, c'est autant d'un tutoriel que je vais écrire sur le dessus de ma tête!

Answer 7

Les sous-classes d'exception représentent les erreurs dont un programme peut raisonnablement récupérer. À l'exception de RuntimeException et de ses sous-classes (voir ci-dessous), elles représentent généralement les erreurs qu'un programme peut rencontrer dans le cours normal de ses fonctions: par exemple, les erreurs de connexion réseau et les erreurs du système de fichiers.

Answer 8

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

2- Une erreur "indique des problèmes sérieux qu'une application raisonnable ne devrait pas tenter d'attraper". tandis que, - Une exception "indique les conditions qu'une application raisonnable pourrait vouloir attraper."

3-Ma directive personnelle est la suivante: une exception est levée lorsqu'une hypothèse fondamentale du bloc de code actuel est trouvée comme étant fausse.

4- Les exceptions vérifiées sont généralement celles à partir desquelles un programme peut récupérer & Il peut être judicieux de récupérer ces exceptions par programmation. Les exemples incluent FileNotFoundException, ParseException, etc. Un programmeur doit vérifier ces exceptions en utilisant le bloc try-catch ou le renvoyer à l'appelant.

D'autre part, nous avons des exceptions non vérifiées. Ce sont ces exceptions qui pourraient ne pas arriver si tout est en ordre, mais elles se produisent. Les exemples incluent ArrayIndexOutOfBoundException, ClassCastException