Excepción lanzada dentro del bloque de captura: ¿se capturará nuevamente?

Esto puede parecer una pregunta de programación 101 y pensé que sabía la respuesta, pero ahora necesito verificarlo dos veces. En el siguiente código, ¿la excepción lanzada en el primer bloque de captura será capturada por el bloque de captura de excepción general a continuación?

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

Siempre pensé que la respuesta sería no, pero ahora tengo un comportamiento extraño que podría ser causado por esto. La respuesta es probablemente la misma para la mayoría de los idiomas, pero estoy trabajando en Java.

No, ya que lo nuevo throwno está en el trybloque directamente.

No. Es muy fácil de 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");
        }
    }
}

Debería imprimir:

En captura IOException: clase java.io.IOException
En finalmente
Excepción en el hilo "main" java.lang.RuntimeException
        en Catch.main (Catch.java:8)

Técnicamente, podría haber sido un error del compilador, un comportamiento no especificado dependiente de la implementación o algo así. Sin embargo, el JLS está bastante bien definido y los compiladores son lo suficientemente buenos para este tipo de cosas simples (el caso de los genéricos puede ser un asunto diferente).

También tenga en cuenta que si intercambia los dos bloques catch, no se compilará. La segunda captura sería completamente inalcanzable.

Tenga en cuenta que el bloque finalmente siempre se ejecuta incluso si se ejecuta un bloque catch (que no sean casos tontos, como bucles infinitos, adjuntando a través de la interfaz de herramientas y matando el hilo, reescribiendo bytecode, etc.).

La especificación del lenguaje Java dice en la sección 14.19.1:

Si la ejecución del bloque try se completa abruptamente debido a un lanzamiento de un valor V, entonces hay una opción:

• Si el tipo de tiempo de ejecución de V es asignable al parámetro de cualquier cláusula catch de la declaración try, entonces se selecciona la primera cláusula catch (más a la izquierda). El valor V se asigna al parámetro de la cláusula catch seleccionada y se ejecuta el Bloque de esa cláusula catch. Si ese bloque se completa normalmente, entonces la instrucción try se completa normalmente; si ese bloque se completa abruptamente por alguna razón, entonces la instrucción try se completa abruptamente por la misma razón.

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

En otras palabras, la primera captura adjunta que puede manejar la excepción sí lo hace, y si se arroja una excepción de esa captura, eso no está dentro del alcance de ninguna otra captura para el intento original, por lo que no intentarán manejarla.

Una cosa relacionada y confusa de saber es que en una estructura try- [catch] -finally, un bloque finalmente puede lanzar una excepción y si es así, se pierde cualquier excepción lanzada por el bloque try o catch. Eso puede ser confuso la primera vez que lo ves.

Si desea lanzar una excepción desde el bloque catch, debe informar su método / clase / etc. que necesita lanzar dicha excepción. Al igual que:

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

Y ahora tu compilador no te gritará :)

No, como dijo Chris Jester-Young, se lanzará al próximo try-catch en la jerarquía.

Como se dijo anteriormente ...
Agregaría que si tiene problemas para ver lo que está sucediendo, si no puede reproducir el problema en el depurador, puede agregar un rastro antes de volver a lanzar la nueva excepción (con el buen sistema anterior .out.println en el peor de los casos, con un buen sistema de registro como log4j).

No será atrapado por el segundo bloque de captura. Cada excepción se captura solo cuando está dentro de un bloque de prueba. Sin embargo, puede anidar intentos (no es una buena idea en general):

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

No, dado que todas las capturas se refieren al mismo bloque try, por lo que lanzar desde dentro de un bloque catch sería atrapado por un bloque try cerrado (probablemente en el método que llamó a este)

La publicación anterior pero la variable "e" debe ser única:

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