La différence entre try-finally et try-catch

Question

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.
}

Je aime la deuxième version mieux parce que cela me donne accès au Throwable. Est-il une différence logique ou une convention préférée entre les deux variantes?

Aussi, est-il un moyen d'accéder à l'exception de la clause finally?

Answer 1

Ce sont deux choses différentes:

• Le bloc catch est exécutée seulement si une exception est levée dans le bloc d'essai.
• Le bloc finally est exécuté toujours après le bloc try (-CATCH), si une exception est 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 dit dans son commentaire, il n'y a pas moyen d'accéder à l'exception à l'intérieur du bloc finally, parce que le bloc est finalement exécuté même s'il ne fait pas exception.

vous pouvez bien sûr déclarer une variable qui détient l'exception en dehors de votre bloc et attribuer 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
    }
}

Answer 2

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

Answer 3

Enfin et les blocs catch sont tout à fait différents:

• Dans le bloc catch, vous pouvez répondre à l'exception lancée. Ce bloc est exécutée que s'il y a une exception non gérée et le type correspond à celui ou est sous-classe de celui spécifié dans le paramètre du bloc catch.
• Enfin sera toujours exécuté après les blocs try et catch s'il y a une exception soulevée ou non.

---

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
}

de manière significative.

Si vous définissez un bloc d'essai, vous devez définir

1. un bloc finally, ou
2. un ou plusieurs blocs catch, ou
3. un ou plusieurs blocs capture et un bloc finally

Ainsi, le code suivant serait valide aussi:

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
}

Answer 4

try {
    statements;
} catch (exceptionType1 e1) {      // one or multiple
    statements;                 
} catch (exceptionType2 e2) {
    statements;
}    
...
} finally {                                 // one or none
    statements;
}

1. Toutes les instructions try doit inclure soit une clause catch ou finally
2. Il peut y avoir un plusieurs clauses catch mais une seule clause finally
3. Pendant toute exécution, en cas d'erreur se produit, le contrôle est transféré au bloc de capture approprié et exécute les instructions et enfin bloc est exécuté.

Quel que soit le bloc finally est toujours exécuté, donc en général, enfin le bloc est utilisé, lorsque vous avez des sessions, des connexions de base de données ou fichiers ou des sockets sont ouverts, le code pour fermer ces connexions seront placés. Ceci est juste pour vous assurer que dans une application aucune fuite de mémoire ou toute autre question ne devrait pas se produire.

Answer 5

Enfin et les blocs catch sont tout à fait différents:

Dans le bloc catch, vous pouvez répondre à l'exception levée. Ce bloc est exécuté seulement s'il y a une exception non gérée et le type correspond à celui ou est sous-classe de celui spécifié dans le paramètre du bloc catch. Enfin sera toujours exécuté après des blocs try et catch s'il y a une exception soulevée ou non.

Answer 6

essayer est utilisé pour exécuter une méthode qui peut lancer une exception

capture est utilisé pour l'arrêt "de capture" cette exception

enfin est utilisé pour tout nettoyage nécessaire de cette exception être pris 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
}

Answer 7

Dans mes recherches bloc Enfin est toujours exécuté et il est principalement « utilisé pour les connexions ouvertes à toute proche » et de détruire quelque chose qui est en cours d'exécution inutilement.

Answer 8

Enfin le bloc est toujours exécuté. bloc Catch est exécutée uniquement lorsqu'une exception qui correspond aux blocs paramètre est attrapées.

Answer 9

Même dans la première forme vous pourrait-il se connecter dans la méthode d'appel. Donc, il n'y a pas grand avantage à moins que vous voulez faire un traitement spécial là.

Answer 10

En général, lorsque nous utilisons des ressources comme les ruisseaux, les connexions etc .. nous devons les fermer en utilisant explicitement finally. Dans le programme ci-dessous nous en train de lire les données à partir d'un fichier en utilisant FileReader et nous fermons l'aide finally.

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 cherché quelque chose comme ça.

Informations cette page tutpoint

Answer 11

bloc Try tiendra les déclarations qui vont exception raise. Le bloc catch tiendra la référence jeté du bloc d'essai et les messages nécessaires sont générés par bloc catch. Enfin bloc est également utilisé pour fermer les ressources utilisées comme clôture io, la fermeture de fichiers, dB fermeture .. En Java -9 améliorée essayer avec des ressources est venu où les ressources sont déclarées en dehors du try..in enchanced essayer avec des ressources du bloc de capture est obligatoire