Instruction de retour en Java

Introduction

Comme nous le savons, Java est un langage de programmation orienté objet. C'est le concept de base, car dire que la base des fondamentaux est que tout est objet. Les objets sont décrits à l'aide de classes. Les classes, à leur tour, ont un état et un comportement. Par exemple, un compte bancaire peut avoir un état sous la forme du montant d'argent sur le compte et avoir le comportement d'augmenter et de diminuer le solde. Le comportement en Java est implémenté à l'aide de méthodes. Comment décrire les méthodes est présenté au tout début de votre parcours d’apprentissage Java. Par exemple, dans le tutoriel officiel d'Oracle : « Defining Methods ». Il y a ici deux aspects importants :

• Chaque méthode a une signature. La signature se compose du nom de la méthode et de ses paramètres d'entrée ;
• Les méthodes doivent spécifier un type de retour ;
• Le type de retour ne fait pas partie de la signature de la méthode.

Encore une fois, cela est une conséquence du fait que Java est un langage fortement typé et que le compilateur souhaite, autant que possible, comprendre à l'avance quels types sont utilisés et où. Encore une fois, pour nous protéger des erreurs. En général, tout est pour le bien. Eh bien, cela nous inculque une fois de plus une culture du traitement des données, me semble-t-il. Ainsi, pour les méthodes, le type valeur est spécifié. Et pour renvoyer cette même valeur des méthodes, le mot-clé est utilisé return.

Instruction de retour de mot clé en Java

Le mot-clé instruction returnfait référence aux « instructions de flux de contrôle » comme indiqué dans le didacticiel Oracle « Instructions de flux de contrôle ». Vous pouvez également lire comment renvoyer des valeurs dans le tutoriel officiel : « Renvoyer une valeur à partir d'une méthode ». Le compilateur surveille attentivement, au mieux de ses capacités, que la valeur renvoyée par une méthode correspond au type de valeur de retour spécifié par la méthode. Prenons l'exemple de l'IDE en ligne de tutorielspoint . Regardons l'exemple original :

public class HelloWorld {
    public static void main(String []args) {
        System.out.println("Hello World");
    }
}

Comme nous pouvons le voir, une méthode est exécutée ici main, qui est le point d'entrée du programme. Les lignes de code sont exécutées de haut en bas. Notre mainméthode ne peut pas renvoyer de valeurs, sinon nous recevrons une erreur : " Error: Main method must return a value of type void". Par conséquent, la méthode affichera simplement à l’écran. Déplaçons maintenant la réception de la chaîne vers une méthode distincte pour recevoir 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, en utilisant le mot-clé, returnnous avons spécifié la valeur de retour, que nous avons utilisée plus tard dans la méthode println. Dans la description (définition) de la méthode, getHelloMessagenous avons indiqué qu'elle nous renverrait String. Cela permet au compilateur de vérifier que les actions de la méthode sont cohérentes avec la manière dont elle est déclarée. Naturellement, le type de valeur de retour spécifié dans la définition de la méthode peut être plus large que le type de valeur renvoyée par le code, c'est-à-dire L'essentiel est que les types soient réduits les uns aux autres. Sinon, nous obtiendrons une erreur de compilation : " error: incompatible types". D’ailleurs, la question s’est probablement immédiatement posée : pourquoi returncela s’applique-t-il aux opérateurs de contrôle de flux de programmes ? Mais parce que cela peut perturber le déroulement normal du programme de haut en bas. Par exemple:

public class HelloWorld {

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

}

Comme le montre l'exemple, nous interrompons l'exécution de la méthode mainsi notre programme java est appelé sans paramètres. Il est important de rappeler que si vous returndisposez ensuite du code, celui-ci devient inaccessible. Et notre compilateur intelligent le remarquera et ne vous permettra pas d'exécuter un tel programme. Par exemple, ce code ne compilera pas :

public static void main(String []args) {
        System.out.println("1");
        return;
        System.out.println("2");
 }

Il existe un sale hack pour contourner ce problème. Par exemple, à des fins de débogage ou pour toute autre raison. Le code ci-dessus peut être corrigé en l'enveloppant returndans ifun bloc :

if (2==2)  {
    return;
}

Instruction de retour dans la gestion des erreurs

Il existe une circonstance très délicate : nous pouvons l'utiliser returnconjointement avec la gestion des erreurs. Je voudrais dire tout de suite que l'utiliser returnen catchbloc est de très, très mauvaise forme, vous devriez donc l'éviter. Mais il nous faut un exemple, non ? Il est la:

public class HelloWorld  {

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

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

}

À première vue, il semble que 2 doive être renvoyé, car finallyil est toujours exécuté. Mais non, la valeur sera 1 et la modification de la variable finallysera ignorée. De plus, s'il valuecontenait un objet et que nous finallydisions value = null, alors il catchrenverrait toujours une référence à l'objet, pas null. Mais depuis le bloc, finallyl'opérateur returnaurait fonctionné correctement. Les collègues ne vous remercieront clairement pas pour un tel cadeau.

vide.classe

Et enfin. Vous pouvez écrire une construction étrange comme void.class. Il semblerait, pourquoi et à quoi ça sert ? En fait, dans divers frameworks et cas délicats où l'API Java Reflection est utilisée , cela peut être très nécessaire. Par exemple, vous pouvez vérifier quel type renvoie une méthode :

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 frameworks de tests où il est nécessaire de remplacer le vrai code des méthodes. Mais pour ce faire, vous devez comprendre comment se comporte cette méthode (c’est-à-dire quels types elle renvoie). Il existe une deuxième façon d'implémenter la méthode mainà partir du code ci-dessus :

public static void main (String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }

Une discussion plutôt intéressante sur la différence entre eux peut être lue sur stackoverflow : quelle est la différence entre java.lang.Void et void ? #Viacheslav