Um bloco finalmente é executado mesmo se você lançar uma nova exceção?

Nesse código será someVardefinido mesmo se o bloco catch for executado e a segunda exceção for lançada?

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

Sim, os blocos finalmente sempre são executados ... exceto quando:

• O encadeamento executando o bloco try-catch-finalmente é interrompido ou interrompido
• Você usa System.exit(0);
• A VM subjacente é destruída de alguma outra maneira
• O hardware subjacente é inutilizável de alguma forma

Além disso, se um método no seu bloco finalmente lança uma exceção não capturada, nada depois será executado (ou seja, a exceção será lançada como faria em qualquer outro código). Um caso muito comum onde isso acontece é java.sql.Connection.close().

Como um aparte, acho que o exemplo de código que você usou é apenas um exemplo, mas tome cuidado para colocar a lógica real dentro de um bloco final. O bloco final é destinado à limpeza de recursos (fechando conexões com o banco de dados, liberando identificadores de arquivos etc.), não para a lógica de execução obrigatória. Se for necessário executá-lo antes do bloco try-catch, afaste-se de algo que possa gerar uma exceção, pois sua intenção é quase certamente funcionalmente a mesma.

Sim.

Veja a documentação :

O bloco finalmente sempre é executado quando o bloco try termina.

Exceções:

Nota: Se a JVM sair enquanto o código try ou catch estiver sendo executado, o bloco finalmente poderá não ser executado. Da mesma forma, se o encadeamento que executa o código try ou catch for interrompido ou eliminado, o bloco finalmente pode não ser executado, mesmo que o aplicativo como um todo continue.

Finalmente, o bloco sempre é executado.

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();
    }
}

}

Finalmente, é sempre executado, não importa qual seja o seu caso.

• bloco try-catch-finalmente
• joga

Para exceções não verificadas, o java não exige, tratamento de erros. sendo esse o motivo, se ocorrer uma exceção desmarcada no bloco finalmente e não for feito nenhum tratamento para isso, o código escrito abaixo desse ponto (onde ocorreu o erro) não será executado.

Por isso, sugiro sempre lidar com todas as exceções, sejam marcadas ou desmarcadas. Dessa forma, você pode garantir que o bloco de código finalmente também seja executado, independentemente da ocorrência de exceção não verificada. você tem um lugar na captura de subninho e finalmente bloqueia para fazer o trabalho necessário.

O bloco finalmente sempre é executado quando o bloco try é encerrado. A menos que você tenha System.exit (0) na sua tentativa ou captura.

Sim. finallyO bloco é executado sempre, exceto no caso em que você chama System.exit () porque interrompe o Java VM.