Blocchi try-finally annidati

[M@P]

Dato il seguente codice:

public class Test {
	public static void test() throws ArrayStoreException, ArithmeticException, InterruptedException {
		try {
			//...
			try {
				//...
				try {
					//...
				} finally {
					System.out.println("inner-inner-finally");
					throw new InterruptedException();
				}	
			} finally {
				System.out.println("inner-finally");
				throw new ArrayStoreException();
			}	
		} finally {
			System.out.println("finally");
			throw new ArithmeticException();
		}	
	}	
	
	public static void main(String[] args) {
		try {
			test();
		} catch (ArrayStoreException e) {
			System.out.println("main -> exception: ArrayStoreException");
		} catch (InterruptedException e) {
			System.out.println("main -> exception: InterruptedException");
		} catch (ArithmeticException e) {
			System.out.println("main -> exception: ArithmeticException");
		}
	}
}

Ed il seguente output:

inner-inner-finally
inner-finally
finally
main -> exception: ArithmeticException

Vorrei capire che cosa ne è delle due eccezioni lanciate all'interno dei due finally annidati. L'output lascia intendere che vengano "scordati", però in che modo e secondo quale logica?

P.S. Le classi delle eccezioni le ho scelte casualmente con il solo fine che fossero una diversa dalle altre.

[andbin]

Originariamente inviato da M@P
Vorrei capire che cosa ne è delle due eccezioni lanciate all'interno dei due finally annidati. L'output lascia intendere che vengano "scordati", però in che modo e secondo quale logica?

Ogni metodo ha solo 1 "ragione" di uscita. E in casi in cui durante il flusso del metodo vengano eseguite più operazioni che causano un certo motivo di uscita, l'ultimo è quello preso in considerazione mentre gli altri semplicemente vengono "scordati".

Succederebbe anche con:

public static int test() {
    try {
        throw new ArithmeticException();
    } finally {
        return 10;
    }
}

Così sembrerebbe che il metodo debba uscire per la eccezione. No, ritorna semplicemente 10 senza lanciare di fuori alcuna eccezione. La ArithmeticException viene "scordata" perché nel finally si imposta una nuova ragione di uscita che è il ritorno di 10.

Sono questioni un po' "trabocchetto" (e se si fanno i test per una certificazione come la SCJP possono anche saltare fuori ). Ma non c'è moltissimo da capire, basta seguire il flusso e tenere per buona l'ultima ragione di uscita sapendo che le altre vengono scordate.

[M@P]

Originariamente inviato da andbin Sono questioni un po' "trabocchetto" (e se si fanno i test per una certificazione come la SCJP possono anche saltare fuori ). Ma non c'è moltissimo da capire, basta seguire il flusso e tenere per buona l'ultima ragione di uscita sapendo che le altre vengono scordate.

Io, per l'appunto lo chiedo perchè sono intenzionato in futuro a prendere la certificazione SCJP, comunque ti ringrazio della ottima spiegazione, adesso mi è tutto più chiaro.