Ha senso fare "try-finally" senza "catturare"?

Ho visto un codice come questo:

    try
    {
        db.store(mydata);
    }
    finally
    {
        db.cleanup();
    }

Ho pensato che trydovrebbe avere un catch?

Perché questo codice lo fa in questo modo?

Ciò è utile se si desidera che il metodo attualmente in esecuzione generi ancora l'eccezione consentendo al contempo di ripulire le risorse in modo appropriato. Di seguito è riportato un esempio concreto di gestione dell'eccezione da un metodo di chiamata.

public void yourOtherMethod() {
    try {
        yourMethod();
    } catch (YourException ex) {
        // handle exception
    }
}    

public void yourMethod() throws YourException {
    try {
        db.store(mydata);
    } finally {
        db.cleanup();
    }
}

È lì perché il programmatore ha voluto assicurarsi che db.cleanup()venga chiamato anche se il codice all'interno del blocco try genera un'eccezione. Eventuali eccezioni non verranno gestite da quel blocco, ma verranno propagate verso l'alto solo dopo l'esecuzione del blocco finally.

Perché questo codice lo fa in questo modo?

Perché apparentemente il codice non sa come gestire le eccezioni a questo livello. Va bene - fintanto che fa uno dei chiamanti, vale a dire fino a quando l'eccezione viene gestita da qualche parte.

Spesso, il codice di basso livello non può reagire in modo appropriato alle eccezioni perché l'utente deve essere avvisato o l'eccezione deve essere registrata o un'altra strategia deve essere provata. Il codice di basso livello svolge una sola funzione e non conosce il processo decisionale di livello superiore.

Ma il codice ha ancora bisogno di ripulire le sue risorse (perché se non lo fa, perderebbero), quindi fa proprio questo nel file finally clausola, assicurandosi che accada sempre , indipendentemente dal fatto che sia stata generata un'eccezione.

Il blocco finally garantisce che anche quando viene generata una RuntimeException (forse a causa di un bug nel codice chiamato), il db.cleanup() verrà effettuata chiamata.

Questo è anche spesso usato per prevenire un eccesso di nidificazione:

try
{
    if (foo) return false;
    //bla ...
    return true;
}
finally
{
    //clean up
}

Soprattutto quando ci sono molti punti in cui il metodo ritorna, questo migliora la leggibilità in quanto chiunque può vedere il codice di pulizia viene chiamato in ogni caso.

Il codice lo sta facendo per garantire che il database sia chiuso.
Di solito, il modo in cui lo faresti è inserire tutto il tuo codice di accesso al database nel blocco try e quindi effettuare una chiamata per chiudere il database nel blocco finally.
Il modo in cui try ... finally funziona, significa che il codice nel blocco try viene eseguito e il codice nel blocco finally viene eseguito al termine ... indipendentemente da cosa.
A meno che il computer non venga strappato dal muro, finalmente verrà eseguito.
Ciò significa che anche se viene chiamata un'eccezione e l'esecuzione del metodo richiede tre anni, andrà comunque nel blocco finally e il database verrà chiuso.

Se uno dei codici nel blocco try è in grado di generare un'eccezione controllata, deve apparire nella clausola dei tiri della firma del metodo. Se viene generata un'eccezione non selezionata, viene espulsa dal metodo.

Il blocco finally viene sempre eseguito, indipendentemente dal fatto che venga generata un'eccezione.