CodeGym/Blog Java/France/Mot clé Java return
Auteur
Jesse Haniel
Lead Software Architect at Tribunal de Justiça da Paraíba

Mot clé Java return

Publié dans le groupe France
membres
Comme nous le savons, le langage Java est un langage de programmation orienté objet. En d'autres termes, le concept fondamental, c'est-à-dire la base de la base, est que tout est un objet. Les objets sont décrits à l'aide de classes. Les classes, quant à elles, définissent l'état et le comportement. Par exemple, un compte bancaire peut avoir un état sous la forme du montant d'argent dans le compte et avoir des comportements qui augmentent et réduisent le solde du compte. En Java, les comportements sont implémentés par les méthodes. L'apprentissage de la définition de méthodes a lieu au tout début de tes études Java. Par exemple, dans le tutoriel officiel d'Oracle, tu le trouveras sous le titre « Définir des méthodes ». Il y a ici deux choses importantes à noter :
  • Chaque méthode a une signature. La signature est composée du nom de la méthode et de ses paramètres d'entrée.
  • Un type de retour doit être spécifié pour les méthodes. Tu déclares le type de retour d'une méthode dans sa déclaration de méthode.
Le type de retour ne fait pas partie de la signature de la méthode. Encore une fois, c'est une conséquence du fait que Java est un langage fortement typé et que le compilateur veut savoir quels types sont utilisés et où, à l'avance et dans la pleine mesure du possible. Encore une fois, c'est pour nous empêcher de faire des erreurs. Donc fondamentalement, tout cela est pour une bonne cause. Et il me semble que cela nous inculque d'autant plus une certaine culture du traitement des données. Ainsi, le type de valeur de retour est spécifié pour les méthodes. Et le mot clé return en Java est utilisé pour effectuer concrètement ce retour.

Ce que fait Java return (return en Java)

Le mot clé Java return est une instruction de flux de contrôle, comme décrit dans le tutoriel d'Oracle ici. Tu peux également découvrir la façon de retourner des valeurs dans la section « Renvoyer une valeur à partir d'une méthode » dans le tutoriel officiel. Le compilateur vérifie soigneusement qu'il peut s'assurer que la valeur de retour d'une méthode correspond au type de retour spécifié de la méthode. Utilisons l'EDI en ligne de Tutorialspoint pour prendre un exemple. Observe cet exemple très simple :
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
Comme nous pouvons le voir, la méthode main, à savoir le point d'entrée du programme, est exécutée ici. Les lignes de code sont exécutées de haut en bas. Notre méthode main ne peut pas renvoyer de valeur. Si nous essayons de lui faire renvoyer une valeur, nous aurons une erreur : « Error: Main method must return a value of type void ». Ainsi, la méthode ne fait qu'afficher la chaîne à l'écran. Maintenant, nous allons déplacer la chaîne littérale dans une méthode distincte pour générer le message :
public class HelloWorld {

    public static void main(String[] args) {
        System.out.println(getHelloMessage());
    }

    public static String getHelloMessage() {
        return "Hello World";
    }

}
Comme nous pouvons le voir, nous avons utilisé le mot clé return pour indiquer la valeur de retour, que nous avons ensuite transmise à la méthode printIn. La déclaration de la méthode getHelloMessage indique que la méthode renverra une valeur String. Cela permet au compilateur de vérifier que les actions de la méthode sont compatibles avec la façon dont elle est déclarée. Naturellement, le type de retour spécifié dans une déclaration de méthode peut être plus large que le type de valeur effectivement retourné dans le code. L'important est qu'une conversion de type soit possible. Sinon, nous aurons une erreur au moment de compiler : « Error: incompatible types ». Au passage, tu te poses probablement une question : Pourquoi return est-il considéré comme une instruction de flux de contrôle ? C'est parce qu'il peut perturber le déroulement normal d'un programme. Exemple :
public class HelloWorld {

    public static void main(String[] args) {
        if (args.length == 0) {
            return;
        }
        for (String arg : args) {
            System.out.println(arg);
        }
    }

}
Comme tu peux le voir dans l'exemple, nous interrompons la méthode main dans le programme Java si elle est appelée sans arguments. Il est important de te rappeler que si tu as du code après une instruction return, ce code ne sera pas accessible. Notre compilateur intelligent le remarquera et t'empêchera d'exécuter un tel programme. Par exemple, le code qui suit ne compile pas :
public static void main(String[] args) {
        System.out.println("1");
        return;
// we use output method after return statement, which is incorrect
        System.out.println("2");
 }
Il y a une vilaine petite astuce pour contourner cela. Par exemple, à des fins de débogage, ou pour une autre raison. Le code ci-dessus peut être corrigé en enveloppant l'instruction return dans un bloc if :
if (2==2) {
    return;
}

Instruction return lors du traitement des erreurs

Il y a quelque chose d'autre de très délicat : nous pouvons utiliser return conjointement avec le traitement des erreurs. Je tiens à dire tout de suite que l'utilisation d'une instruction return dans un bloc catch est une très, très mauvaise habitude, et donc que tu devrais l'éviter. Mais nous avons besoin d'un exemple, n'est-ce pas ? Et voilà :
public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Value: " + getIntValue());
    }

    public static int getIntValue() {
        int value = 1;
        try {
            System.out.println("Something terrible happens");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("Cached value: " + value);
            return value;
        } finally {
            value++;
            System.out.println("New value: " + value);
        }
    }

}
À première vue, il semble que 2 devrait être retourné, car finally est toujours exécuté. Mais non, la valeur de retour sera de 1, et la modification de la variable dans le bloc finally sera ignorée. De plus, supposons que value contient un objet et que nous disons que value = null dans le bloc finally. Dans ce cas, cet objet, non nul, serait retourné dans le bloc catch. Mais une instruction return fonctionnerait correctement dans le bloc finally. Évidemment, tes collègues ne te remercieront pas pour ce genre de petites surprises concernant les instructions return. Mot clé Java return - 1

void.class

Et finally. Il existe une construction étrange que tu peux écire : void.class. Hmm. Pourquoi, et qu'est-ce-que cela veut dire ? Il existe vraiment différents cadres et cas délicats impliquant l'API Java Reflection où cela peut être très utile. Par exemple, tu peux vérifier le type qu'une méthode renvoie :
import java.lang.reflect.Method;

public class HelloWorld {

    public void getVoidValue() {
    }

    public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == void.class);
        }
    }
}
Cela peut être utile dans les cadres de tests où tu dois remplacer le code réel dans les méthodes. Mais pour ce faire, tu dois comprendre comment une méthode se comporte (c'est-à-dire quel type elle renvoie). Il existe également une deuxième façon d'implémenter la méthode main dans le code ci-dessus :
public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }
Tu peux lire une discussion (en anglais) très intéressante sur la différence entre les deux sur Stack Overflow : Quelle est la différence entre java.lang.Void et void ?
Commentaires
  • Populaires
  • Nouveau
  • Anciennes
Tu dois être connecté(e) pour laisser un commentaire
Cette page ne comporte pas encore de commentaires