Exceção lançada dentro do bloco de captura - será capturada novamente?

Isso pode parecer uma questão de programação e eu pensei que sabia a resposta, mas agora me vejo precisando checar novamente. Neste trecho de código abaixo, a exceção lançada no primeiro bloco de captura será capturada pelo bloco de exceção geral abaixo?

try {
  // Do something
} catch(IOException e) {
  throw new ApplicationException("Problem connecting to server");
} catch(Exception e) {
  // Will the ApplicationException be caught here?
}

Eu sempre pensei que a resposta seria não, mas agora tenho um comportamento estranho que pode ser causado por isso. A resposta é provavelmente a mesma para a maioria das linguagens, mas estou trabalhando em Java.

Não, pois o novo thrownão está no trybloco diretamente.

Não. É muito fácil verificar.

public class Catch {
    public static void main(String[] args) {
        try {
            throw new java.io.IOException();
        } catch (java.io.IOException exc) {
            System.err.println("In catch IOException: "+exc.getClass());
            throw new RuntimeException();
        } catch (Exception exc) {
            System.err.println("In catch Exception: "+exc.getClass());
        } finally {
            System.err.println("In finally");
        }
    }
}

Deve imprimir:

Em captura IOException: classe java.io.IOException
Finalmente
Exceção no encadeamento "main" java.lang.RuntimeException
        em Catch.main (Catch.java:8)

Tecnicamente, isso poderia ter sido um bug do compilador, dependente da implementação, comportamento não especificado ou algo assim. No entanto, o JLS é muito bem definido e os compiladores são bons o suficiente para esse tipo de coisa simples (a caixa de canto genérica pode ser uma questão diferente).

Observe também que, se você trocar os dois blocos catch, ele não será compilado. A segunda captura seria completamente inacessível.

Observe que o bloco final sempre é executado mesmo que um bloco coletor seja executado (exceto casos estúpidos, como loops infinitos, anexando-se à interface das ferramentas e eliminando o encadeamento, reescrevendo o código de código, etc.).

A especificação da linguagem Java diz na seção 14.19.1:

Se a execução do bloco try for concluída abruptamente devido a um lançamento de um valor V, haverá uma opção:

• Se o tipo de tempo de execução de V for atribuível ao Parâmetro de qualquer cláusula catch da instrução try, a primeira cláusula catch (mais à esquerda) será selecionada. O valor V é atribuído ao parâmetro da cláusula catch selecionada e o bloco dessa cláusula catch é executado. Se esse bloco for concluído normalmente, a instrução try será concluída normalmente; se esse bloco for concluído abruptamente por qualquer motivo, a instrução try será concluída abruptamente pelo mesmo motivo.

Referência: http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#24134

Em outras palavras, a primeira captura anexa que pode lidar com a exceção, e se uma exceção é lançada fora dessa captura, isso não está no escopo de nenhuma outra captura para a tentativa original, portanto, eles não tentarão lidar com isso.

Uma coisa relacionada e confusa a saber é que em uma estrutura try- [catch] -finally, um bloco finalmente pode lançar uma exceção e, nesse caso, qualquer exceção lançada pelo bloco try ou catch é perdida. Isso pode ser confuso na primeira vez que você o vê.

Se você deseja lançar uma exceção do bloco catch, deve informar seu método / classe / etc. que ele precisa lançar a exceção. Igual a:

public void doStuff() throws MyException {
    try {
        //Stuff
    } catch(StuffException e) {
        throw new MyException();
    }
}

E agora seu compilador não gritará com você :)

Não - como Chris Jester-Young disse, ele será lançado para a próxima tentativa na hierarquia.

Como dito acima ...
Eu acrescentaria que, se você tiver problemas para ver o que está acontecendo, se não conseguir reproduzir o problema no depurador, poderá adicionar um rastreio antes de lançar novamente a nova exceção (com o bom e antigo System .out.println, na pior das hipóteses, com um bom sistema de log como o log4j).

Não será capturado pelo segundo bloco de captura. Cada exceção é capturada apenas quando dentro de um bloco try. Você pode aninhar tentativas (não que seja uma boa ideia em geral):

try {
    doSomething();
} catch (IOException) {
   try {
       doSomething();
   } catch (IOException e) {
       throw new ApplicationException("Failed twice at doSomething" +
       e.toString());
   }          
} catch (Exception e) {
}

Não, uma vez que todas as capturas se referem ao mesmo bloco de tentativa, portanto, jogar de dentro de um bloco de captura seria capturado por um bloco de tentativa anexo (provavelmente no método que chamou esse)

Postagem antiga, mas a variável "e" deve ser única:

try {
  // Do something
} catch(IOException ioE) {
  throw new ApplicationException("Problem connecting to server");
} catch(Exception e) {
  // Will the ApplicationException be caught here?
}