Differenza tra try-finally e try-catch

Question

Qual è la differenza tra

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

E

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

Mi piace di più la seconda versione perché mi dà accesso a Throwable.C'è qualche differenza logica o una convenzione preferita tra le due varianti?

Inoltre, c'è un modo per accedere all'eccezione dalla clausola final?

Answer 1

Si tratta di due cose diverse:

• Il blocco catch viene eseguito solo se viene generata un'eccezione nel blocco try.
• Il blocco finally viene eseguito sempre dopo il blocco try (-Catch), se viene generata un'eccezione oppure no.

Nel tuo esempio non hai mostrato la terza possibile costrutto:

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
}

E, come @codeca dice nel suo commento, non v'è alcun modo per accedere l'eccezione all'interno del blocco finally, perché il blocco finally viene eseguito anche se non esiste alcuna eccezione.

Naturalmente si potrebbe dichiarare una variabile che contiene l'esterno ad eccezione del blocco e assegnare un valore all'interno del blocco catch. In seguito è possibile accedere a questa variabile all'interno del blocco finally.

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

Answer 2

Questi non sono variazioni, sono cose radicalmente diverse. finally viene eseguito sempre , solo catch quando si verifica un'eccezione.

Answer 3

Infine, i blocchi catch sono abbastanza diversi:

• All'interno del blocco catch puoi rispondere all'eccezione lanciata.Questo blocco viene eseguito solo se è presente un'eccezione non gestita e il tipo corrisponde a quello o è una sottoclasse di quella specificata nel parametro del blocco catch.
• Infine verrà sempre eseguito dopo aver provato a catturare i blocchi se è stata sollevata un'eccezione o meno.

---

COSÌ

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
}

si differenzia da

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

in modo significativo.

Se definisci un blocco try devi definire

1. uno finalmente bloccare, o
2. uno o più blocchi catch, o
3. uno o più blocchi catch e un blocco final

Quindi sarebbe valido anche il seguente codice:

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. Tutte le istruzioni try deve includere una clausola catch o un clausola finally
2. può avere un più clausole catch ma solo una clausola finally
3. Durante ogni esecuzione, se si verifica un errore, allora il controllo viene trasferito al blocco Catch appropriato ed esegue le istruzioni ed infine viene eseguito blocco.

Non importa quale sia il blocco finally viene sempre eseguito, Quindi, in generale, blocco finally viene utilizzato, quando si hanno le sessioni, le connessioni di database o file o le prese sono aperte, quindi il codice per la chiusura di queste connessioni sarà collocato. Questo è solo per assicurarsi che in un'applicazione non dovrebbero verificarsi perdite di memoria o qualsiasi altra questione.

Answer 5

Infine e blocchi catch sono molto diversi:

All'interno del blocco catch è possibile rispondere alla eccezione generata. Questo blocco viene eseguito solo se v'è un'eccezione non gestita e il tipo corrisponde a quello o è sottoclasse di quella specificata nel parametro del blocco catch. Infine sarà sempre eseguito dopo try e catch blocchi se v'è un'eccezione sollevata oppure no.

Answer 6

try viene utilizzato per eseguire un metodo che può generare un'eccezione

cattura è usato per "catturare" stop che fa eccezione

, infine, viene utilizzato per qualsiasi up pulita necessaria di tale eccezione di essere catturati o no

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

Nella mia ricerca blocco finally viene sempre eseguito ed è principalmente "utilizzato per le eventuali connessioni aperte per chiudere" e di distruggere qualcosa che esegue inutilmente.

Answer 8

Infine blocco viene sempre eseguito. blocco Catch viene eseguito solo quando un'eccezione che corrisponde ai blocchi parametro viene catturato.

Answer 9

Anche nella prima forma che si potrebbe accedere nel metodo chiamante. Quindi non v'è alcun vantaggio a meno che non si vuole fare un po 'trattamento speciale proprio lì.

Answer 10

In genere quando usiamo le risorse come ruscelli, connessioni, ecc .. dobbiamo chiudere in modo esplicito utilizzando blocco finally. Nel programma indicato di seguito stiamo leggendo i dati da un file utilizzando FileReader e stiamo chiudendo utilizzando blocco 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();
           }
       }
    }

}

Forse altri ragazzi come me ha cercato qualcosa di simile.

Informazioni da questa pagina tutpoint

Answer 11

blocco Try terrà le dichiarazioni che stanno andando ad eccezione rilancio. Il blocco catch terrà il riferimento gettati dal blocco try e messaggi necessari sono generati dal blocco catch. Infine blocco viene utilizzato anche per chiudere le risorse utilizzate come chiusura io, la chiusura di file, la chiusura dB .. In Java -9 migliorato try-con risorse si avvicinò in cui le risorse sono dichiarati fuori della try..in enchanced provare con delle risorse blocco catch è obbligatoria