try-catch-finally avec retour après

Je sais comment try, catch & enfin travailler (pour la plupart), mais j'ai une chose que je me demandais: qu'advient-il avec une instruction de retour après un try-catch-finally, alors que nous avions déjà eu un retour dans le try (ou capture)?

Par exemple:

public boolean someMethod(){
    boolean finished = false;
    try{
        //do something
        return true;
    }
    catch(someException e){
        //do something
    }
    finally{
        //do something
    }
    return finished;
}

Disons que rien de ce qui s'est passé dans le coup d'essayer, alors nous sommes retournés vrai. Ensuite, nous irons à la où enfin nous faire quelque chose comme la fermeture d'une connexion, et alors?

Le mode d'arrêt après que nous avons fait des trucs dans le enfin (de sorte que le renvoi de la méthode de vrai dans l'essai), ou la méthode de continuer après le enfin encore une fois, résultant en un retour fini (ce qui est faux)?

Merci d'avance pour les réponses.

source d'informationauteur Kevin Cruijssen

  1. 14

    Le fait que le bloc finally est exécuté n'est pas de rendre le programme vous oubliez retourné. Si tout va bien, le code après le bloc finally ne sera pas exécutée.

    Voici un exemple qui met en évidence:

    public class Main {

    public static void main(String[] args) {
        System.out.println("Normal: " + testNormal());
        System.out.println("Exception: " + testException());
    }

    public static int testNormal() {
        try {
            //no exception
            return 0;
        } catch (Exception e) {
            System.out.println("[normal] Exception caught");
        } finally {
            System.out.println("[normal] Finally");
        }
        System.out.println("[normal] Rest of code");
        return -1;
    }

    public static int testException() {
        try {
            throw new Exception();
        } catch (Exception e) {
            System.out.println("[except] Exception caught");
        } finally {
            System.out.println("[except] Finally");
        }
        System.out.println("[except] Rest of code");
        return -1;
    }

}

    De sortie:

    [normal] Finally
Normal: 0
[except] Exception caught
[except] Finally
[except] Rest of code
Exception: -1
  2. 7

    Si tout va bien, retour à l'intérieur de la try est exécutée après l'exécution de la finally bloc.

    Si quelque chose se passe mal à l'intérieur de tryexception est capturé et exécuté, puis finally bloc est exécuté, puis le retour après qui est exécutée.

  3. 3

    Dans ce cas, le code à l'intérieur de la enfin est exécuté, mais l'autre retour est ignorée quand il n'y a pas d'exceptions.
    Vous pouvez également le constater vous-même en vous connectant à quelque chose 🙂

    Voir aussi à ce sujet System.exit:
    Comment Java du Système.exit() travailler avec try/catch/finally blocs?

    Et de voir le retour de l'une de enfin:
    De retour d'un bloc finally en Java

  4. 2
    public int Demo1()
    {
        try{
            System.out.println("TRY");
            throw new Exception();
            }catch(Exception e){
                System.out.println("CATCH");
            }finally{
                System.out.println("FINALLY");
            }return 0;

    }

    la sortie de l'appel à cette méthode, c'est comme cela

    TRY
CATCH
FINALLY
0

    Les moyens Considérer Try{}catch{}finally{} en tant que séquence d'instructions exécutées une par une Dans ce cas particulier.
    Et que le contrôle va revenir.

  5. 0

    Certainement le code à l'intérieur d'essai va exécuter.. mais quand il atteint instruction de retour.. il se déplace sur le bloc finally sans l'exécution de l'instruction de retour dans le bloc try.. et puis le code de enfin être exécutés et ensuite l'instruction de retour d'essayer à exécuter.