Esegue finalmente un blocco anche se si lancia una nuova eccezione?

In questo codice verrà someVarimpostato anche se viene eseguito il blocco catch e viene generata la seconda eccezione?

public void someFunction() throws Exception {
    try {
        //CODE HERE
    } catch (Exception e) {
        Log.e(TAG, "", e);
        throw new Exception(e);
    } finally {
        this.someVar= true;
    }
}

Sì, i blocchi finally funzionano sempre ... tranne quando:

• Il thread che esegue il blocco try-catch-finally viene ucciso o interrotto
• Usate System.exit(0);
• La VM sottostante viene distrutta in qualche altro modo
• L'hardware sottostante è in qualche modo inutilizzabile

Inoltre, se un metodo nel tuo blocco finalmente genera un'eccezione non rilevata, allora nulla verrà eseguito successivamente (ovvero l'eccezione verrà generata come in qualsiasi altro codice). Un caso molto comune in cui ciò accade è java.sql.Connection.close().

Per inciso, immagino che l'esempio di codice che hai usato sia solo un esempio, ma fai attenzione a mettere la logica effettiva all'interno di un blocco finally. Il blocco finally è destinato alla pulizia delle risorse (chiusura delle connessioni DB, rilascio di handle di file, ecc.), Non alla logica da eseguire. Se deve essere eseguito, fallo prima del blocco try-catch, lontano da qualcosa che potrebbe generare un'eccezione, poiché la tua intenzione è quasi certamente funzionalmente la stessa.

Sì.

Vedi la documentazione :

Il blocco finally viene sempre eseguito alla chiusura del blocco try.

eccezioni:

Nota: se la JVM viene chiusa durante l'esecuzione del codice try o catch, il blocco finally potrebbe non essere eseguito. Allo stesso modo, se il thread che esegue il codice try o catch viene interrotto o ucciso, il blocco finally potrebbe non essere eseguito anche se l'applicazione nel suo insieme continua.

Infine, il blocco viene sempre eseguito.

public class ExceptionTest {

public static void someFunction(String input) throws Exception {
    try {
        if( input.equals("ABC") ) {
            System.out.println("Matched");
        }
    } catch (Exception e) {
        throw new Exception(e);
    } finally {
        System.out.println("Input Is "+input+" Finally Executed!!!");
    }
}

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    try {
        System.out.println("********* Test with VALUE ********* ");
        someFunction("ABC");
        System.out.println("\r\n********* Test with NULL  ********* ");
        someFunction(null);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

}

Alla fine viene sempre eseguito, indipendentemente dal tuo caso

• blocco try-catch-finally
• getta

Per eccezioni non controllate, java non richiede, gestione degli errori. questo è il motivo, se si verifica un'eccezione non selezionata nel blocco infine, quindi non viene eseguita alcuna gestione, il codice scritto sotto questo punto (dove si è verificato l'errore) non verrà eseguito.

Quindi suggerisco di gestire sempre tutte le eccezioni che possono essere selezionate o deselezionate. In questo modo puoi assicurarti che anche il blocco di codice sia finalmente eseguito, indipendentemente dal fatto che si verifichi anche un'eccezione non selezionata. hai un posto nella cattura del sotto-nido e infine blocca per completare il lavoro necessario.

Il blocco finally si esegue sempre quando il blocco try viene chiuso. A meno che non si abbia System.exit (0) nel tentativo o nella cattura.

Sì. finallyIl blocco viene eseguito sempre tranne il caso in cui si chiama System.exit () perché arresta la VM Java.