Eccezione generata all'interno del blocco catch: verrà catturata di nuovo?

Potrebbe sembrare una domanda di programmazione 101 e pensavo di conoscere la risposta, ma ora mi trovo a dover ricontrollare. In questa parte di codice riportata di seguito, l'eccezione generata nel primo blocco catch verrà catturata dal blocco catch Eccezione generale di seguito?

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

Ho sempre pensato che la risposta sarebbe stata no, ma ora ho alcuni comportamenti strani che potrebbero essere causati da questo. La risposta è probabilmente la stessa per la maggior parte delle lingue, ma sto lavorando in Java.

No, poiché il nuovo thrownon è trydirettamente nel blocco.

No. È molto facile da controllare.

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

Dovrebbe stampare:

In cattura IOException: classe java.io.IOException
Alla fine
Eccezione nel thread "main" java.lang.RuntimeException
        at Catch.main (Catch.java:8)

Tecnicamente quello avrebbe potuto essere un bug del compilatore, dipendente dall'implementazione, un comportamento non specificato o qualcosa del genere. Tuttavia, il JLS è abbastanza ben definito e i compilatori sono abbastanza buoni per questo tipo di cose semplici (il caso d'angolo generici potrebbe essere una questione diversa).

Inoltre, se si scambiano i due blocchi di cattura, non verranno compilati. La seconda cattura sarebbe completamente irraggiungibile.

Si noti che il blocco finally viene sempre eseguito anche se viene eseguito un blocco catch (diverso dai casi stupidi, come loop infiniti, collegamento tramite l'interfaccia degli strumenti e uccisione del thread, riscrittura tramite codice, ecc.).

La specifica del linguaggio Java dice nella sezione 14.19.1:

Se l'esecuzione del blocco try viene completata bruscamente a causa di un lancio di un valore V, è possibile scegliere:

• Se il tipo di runtime di V è assegnabile al parametro di qualsiasi clausola catch dell'istruzione try, viene selezionata la prima (estrema sinistra) tale clausola catch. Il valore V viene assegnato al parametro della clausola catch selezionata e viene eseguito il blocco di quella clausola catch. Se quel blocco si completa normalmente, allora l'istruzione try si completa normalmente; se quel blocco si completa bruscamente per qualsiasi motivo, l'istruzione try si completa bruscamente per lo stesso motivo.

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

In altre parole, la prima cattura racchiusa in grado di gestire l'eccezione fa, e se un'eccezione viene eliminata da quella cattura, non è nell'ambito di qualsiasi altra cattura per il tentativo originale, quindi non proveranno a gestirla.

Una cosa correlata e confusa da sapere è che in una struttura try- [catch] -finally, un blocco finally può generare un'eccezione e, in tal caso, qualsiasi eccezione generata dal blocco try o catch viene persa. Ciò può confondere la prima volta che lo vedi.

Se vuoi lanciare un'eccezione dal blocco catch devi informare il tuo metodo / classe / ecc. che deve gettare detta eccezione. Così:

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

E ora il tuo compilatore non ti urlerà contro :)

No - Come ha detto Chris Jester-Young, verrà lanciato al prossimo tentativo di cattura nella gerarchia.

Come detto sopra ...
Aggiungerei che se hai problemi a vedere cosa sta succedendo, se non riesci a riprodurre il problema nel debugger, puoi aggiungere una traccia prima di ri-lanciare la nuova eccezione (con il buon vecchio sistema peggio .out.println, con un buon sistema di log come log4j altrimenti).

Non verrà catturato dal secondo blocco di cattura. Ogni eccezione viene rilevata solo all'interno di un blocco try. Puoi nidificare i tentativi (non che sia generalmente una buona idea):

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

No, poiché tutti i catch si riferiscono allo stesso blocco try, quindi il lancio dall'interno di un blocco catch verrebbe catturato da un blocco try incluso (probabilmente nel metodo che ha chiamato questo)

Il vecchio post ma la variabile "e" deve essere unica:

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