Est-il sensé de faire «essayer-enfin» sans «attraper»?

J'ai vu du code comme celui-ci:

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

Je pensais qu'il tryétait censé avoir un catch?

Pourquoi ce code le fait-il de cette façon?

Ceci est utile si vous souhaitez que la méthode en cours d'exécution lève toujours l'exception tout en permettant le nettoyage approprié des ressources. Voici un exemple concret de gestion de l'exception à partir d'une méthode d'appel.

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

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

C'est là parce que le programmeur voulait s'assurer que cela db.cleanup()est appelé même si le code à l'intérieur du bloc try lève une exception. Toutes les exceptions ne seront pas gérées par ce bloc, mais elles ne seront propagées vers le haut qu'après l'exécution du bloc finally.

Pourquoi ce code le fait-il de cette façon?

Parce qu'apparemment le code ne sait pas comment gérer les exceptions à ce niveau. C'est bien - tant que l'un des appelants le fait, c'est-à-dire tant que l'exception est finalement gérée quelque part.

Souvent, le code de bas niveau ne peut pas réagir correctement aux exceptions car l'utilisateur doit être notifié, ou l'exception doit être enregistrée ou une autre stratégie doit être essayée. Le code de bas niveau remplit une seule fonction et ne connaît pas la prise de décision de plus haut niveau.

Mais le code doit toujours nettoyer ses ressources (car si ce n'est pas le cas, elles fuiraient), il le fait donc dans la finallyclause, en s'assurant que cela se produit toujours , qu'une exception soit levée ou non.

Le bloc finally garantit que même lorsqu'une RuntimeException est lancée (peut-être en raison d'un bogue dans le code appelé), l' db.cleanup()appel sera effectué.

Ceci est également souvent utilisé pour éviter une imbrication excessive:

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

Surtout quand il y a de nombreux points auxquels la méthode retourne, cela améliore la lisibilité car tout le monde peut voir que le code de nettoyage est appelé dans tous les cas.

Le code le fait pour s'assurer que la base de données est fermée.
Habituellement, la façon dont vous le feriez est de mettre tout votre code d'accès à la base de données dans le bloc try, puis de passer un appel pour fermer la base de données dans le bloc finally.
La façon dont try ... enfin fonctionne, signifie que le code du bloc try est exécuté et que le code du bloc finally est exécuté lorsque cela se termine ... quoi qu'il arrive.
À moins que l'ordinateur ne soit arraché du mur, le dernier s'exécutera.
Cela signifie que même si une exception est appelée et que la méthode prend trois ans à s'exécuter, elle ira toujours dans le bloc finally et la base de données sera fermée.

Si l'un des codes du bloc try peut lever une exception vérifiée, il doit apparaître dans la clause throws de la signature de méthode. Si une exception non vérifiée est levée, elle est exclue de la méthode.

Le bloc finally est toujours exécuté, qu'une exception soit levée ou non.