web-dev-qa-db-fra.com

Différence entre try-finally et try-catch

Quelle est la différence entre

try {
    fooBar();
} finally {
    barFoo();
}

et

try {
  fooBar();
} catch(Throwable throwable) {
    barFoo(throwable); // Does something with throwable, logs it, or handles it.
}

J'aime mieux la deuxième version car elle me donne accès au Throwable. Existe-t-il une différence logique ou une convention préférée entre les deux variantes?

En outre, existe-t-il un moyen d'accéder à l'exception à la clause finally?

javatry-catchtry-finally
81
Vijay Kotari

Ce sont deux choses différentes:

  • Le bloc catch n'est exécuté que si une exception est levée dans le bloc try.
  • Le bloc finally est toujours exécuté après le bloc try (-catch), qu’une exception soit levée ou non.

Dans votre exemple, vous n'avez pas montré la troisième construction possible:

try {
    // try to execute this statements...
}
catch( SpecificException e ) {
    // if a specific exception was thrown, handle it here
}
// ... more catches for specific exceptions can come here
catch( Exception e ) {
    // if a more general exception was thrown, handle it here
}
finally {
    // here you can clean things up afterwards
}

Et, comme @codeca le dit dans son commentaire, il n’existe aucun moyen d’accéder à l’exception à l’intérieur du bloc finally, car le dernier bloc est exécuté même s’il n’ya pas d’exception.

Bien sûr, vous pouvez déclarer une variable qui contient l'exception en dehors de votre bloc et affecter une valeur à l'intérieur du bloc catch. Ensuite, vous pouvez accéder à cette variable dans votre bloc finally.

Throwable throwable = null;
try {
    // do some stuff
}
catch( Throwable e ) {
    throwable = e;
}
finally {
    if( throwable != null ) {
        // handle it
    }
}
112
tangens

Ce ne sont pas des variations, ce sont des choses fondamentalement différentes. finally est exécuté toujours, catch uniquement lorsqu'une exception se produit.

11
Michiel Buddingh

Enfin, les blocs catch sont assez différents:

  • Dans le bloc catch, vous pouvez répondre à l'exception levée. Ce bloc n'est exécuté que s'il existe une exception non gérée et que le type correspond à l'un ou à la sous-classe de celui spécifié dans le paramètre du bloc catch.
  • Finalement sera toujours exécuté après try et catch bloque si une exception est levée ou non.

Alors

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if ExceptionA 
  // was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in try 
  // and not handled by first catch block
}

diffère de

try {
  //some code
}
finally {
  // Gets executed whether or not 
  // an exception was thrown in try block
}

significativement.

Si vous définissez un bloc try, vous devez définir

  1. enfin un bloc, ou
  2. un ou plusieurs blocs catch, ou
  3. un ou plusieurs blocs catch et un dernier bloc

Donc, le code suivant serait aussi valide:

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if 
  // ExceptionA was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in 
  // try and not handled by first catch block
}
//even more catch blocks
finally {
  // Gets executed whether or not an 
  // exception was thrown in try block
}
7
TheMorph

Enfin, les blocs catch sont assez différents:

Dans le bloc catch, vous pouvez répondre à l'exception levée. Ce bloc n'est exécuté que s'il existe une exception non gérée et que le type correspond à celui ou à la sous-classe de celui spécifié dans le paramètre du bloc catch. Enfin, sera toujours exécuté après try et catch bloque, qu’une exception soit levée ou non.

4
Android Tutorial

try est utilisé pour exécuter une méthode qui peut générer une exception

catch est utilisé pour "attraper" arrêter cette exception

enfin est utilisé pour tout nettoyage nécessaire à partir de cette exception être capturé ou non

try{
    myObject.riskyMethod(); // run a method that may throw an exception
}
catch(Exception ex){
    myLogger.log(ex.Message); // "catch" stop that exception
}
finally{
    myObject = null; // clean up needed from that exception being caught
}
4
Kieran
try {
    statements;
} catch (exceptionType1 e1) {      // one or multiple
    statements;                 
} catch (exceptionType2 e2) {
    statements;
}    
...
} finally {                                 // one or none
    statements;
}
  1. Toutes les instructions try doivent inclure une clause catch ou une clause finally
  2. Il peut avoir plusieurs clauses de capture mais une seule clause de dernier
  3. Lors de toute exécution, en cas d'erreur, le contrôle est transféré dans le bloc Catch approprié et exécute les instructions. Le bloc Finally est exécuté.

Peu importe ce que le bloc Finally est toujours exécuté, donc en général, le bloc Finally est utilisé, lorsque vous avez des sessions, des connexions à une base de données, des fichiers ou des sockets ouverts, le code permettant de fermer ces connexions est placé. Ceci est juste pour vous assurer que dans une application aucune fuite de mémoire ou aucun autre problème ne devrait se produire.

4
gmhk

Dans Ma recherche Enfin, le bloc est toujours exécuté et il est principalement "utilisé pour fermer toutes les connexions ouvertes" et pour détruire quelque chose qui tourne inutilement.

3
Hari krishna

Enfin, le bloc est toujours exécuté. Le bloc Catch n'est exécuté que lorsqu'une exception correspondant au paramètre de blocs est interceptée.

2
mkorpela

Même dans le premier formulaire, vous pouvez le connecter à la méthode d'appel. Donc, il n'y a pas de gros avantage à moins que vous souhaitiez effectuer une manipulation spéciale sur place.

2
fastcodejava

Généralement, lorsque nous utilisons des ressources telles que des flux, des connexions, etc., nous devons les fermer explicitement à l’aide de bloc. Dans le programme donné ci-dessous, nous lisons les données d'un fichier en utilisant FileReader et nous le fermons en utilisant enfin block.

import Java.io.File;
import Java.io.FileReader;
import Java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]){
      FileReader fr=null;       
      try{
         File file=new File("file.txt");
         fr = new FileReader(file);  char [] a = new char[50];
         fr.read(a); // reads the content to the array
         for(char c : a)
         System.out.print(c); //prints the characters one by one
      }catch(IOException e){
          e.printStackTrace();
       }
       finally{ 
          try{
              fr.close();
          }catch(IOException ex){       
               ex.printStackTrace();
           }
       }
    }

}

Peut-être que d'autres gars comme moi ont cherché quelque chose comme ça.

Informations de cette page tutpoint

2
Florian Neiss