Java 7 e i Doni Tardivi – Seconda Parte

Continuiamo a vedere insieme cosa ci ha portato di nuovo la versione 7 di Java. Nel post precedente abbiamo visto gli string switch e le risorse autoclosable, che possono rendere il codice in caso di try-catch-finally molto più coinciso. Oggi parliamo ancora di innovazioni che girano intorno alla gestione dell’errore.

Horcrux numero 3: rilancia la precisione!

Spesso vorremmo gestire nel catch più di una eccezione di tipo diverso, eseguire delle operazioni e rilanciarle. Vediamo un esempio di codice:

 public static void main(String[] args) throws IOException, SQLException {
        try {
            caricaFileDB();
        } catch (SQLException ex) {
            // logga ex
            throw ex;
        } catch (IOException ex) {
            // logga ex
            throw ex;
        }
    }

Stiamo gestendo ogni tipo di eccezione lanciata dal blocco try per poi rilanciarla. Questo codice però presenta ridondanza: prima di Java 7 l’unico modo di evitarla era di gestire l’eccezione base:

 public static void main(String[] args) throws Exception {
        try {
            caricaFileDB();
        } catch (Exception ex) {
            // gestisci ex
            throw ex;
        } 
    }

Così però abbiamo dovuto rilanciare l’eccezione base java.lang.Exception dal metodo chiamante, perdendo in specificità. Con Java 7 invece:

 public static void main(String[] args) throws IOException, SQLException {
        try {
            caricaFileDB();
        } catch (final Exception ex) {
            // gestisci ex
            throw ex;
        }
    }

Con il final nella clausola catch istruiamo il compilatore a lanciare solo quelle eccezioni checked che non sono state gestisce in nessuno dei blocchi catch precedenti.

Horcrux numero 4: prendi tutto!

In Java 6 non esiste un modo di gestire più eccezioni in un punto solo: questo produce codice boilerplate difficile da leggere e manutenere:

try {
faQualcosa();
} catch(Ex1 ex1) {
gestisciEccezione1();
} catch(Ex2 ex2) {
gestisciEccezione2();
} catch(Ex3 ex3) {
gestisciEccezione3();
}

Java 7 consente invece di gestire eccezioni multiple nel blocco catch nel modo seguente:

 public static void main(String[] args) throws Ex1, Ex2, Ex3, Ex4 {
        try {
            faQualcosa();
        } catch (Ex1 | Ex2 ex) {
            gestisciEccezione12():
        } catch (Ex3 | Ex4 ex) {
            gestisciEccezione34():
        }
    }

Bello, no? Un altro passo verso codice Java più corto e leggibile!

Conclusioni

Altri Horcrux sono stati recuperati, altre piccole migliorie del linguaggio che, nella loro globalità, fanno di Java 7 un linguaggio più coinciso e potente, se pur non rivoluzionario rispetto alla versione precedente. Nel prossimo post andremo alla caccia degli ultimi Horcrux e alla fine avremo ragione dell’Oscuro Signore!

Alla prossima!