Exemples connus de méthodes avec valeur de retour

Vous connaissez déjà quelques méthodes avec valeur de retour :

• celles pour la classe Scanner - comme nextInt(), nextDouble(), nextLine()
• celles pour la classe Math - comme Math.pow() et Math.sqrt()
• celles pour la classe String - comme length() et toUpperCase()

Exemples connus de méthodes sans valeur de retour

Les méthodes sans valeur de retour ont le type de retour void. Elles sont souvent utilisées pour des actions qui modifient directement l’état de la mémoire du programme ou qui font des sorties (comme afficher à l’écran ou enregistrer dans un fichier).

Ceux que vous connaissez le mieux sont les méthodes :

• main - qui ne retourne rien au système d’exploitation : sa fin est la fin du programme
• println, print et printf de System.out - qui affichent des messages à la console

Il y a quelques indices que ces méthodes ne retournent pas de valeur :

1. On ne déclare aucune variable pour recevoir la valeur retourné (car il n’y en a pas)
2. Le mot-clé void précède immédiatment le nom de la méthode dans la déclaration, p. ex. void main() ou sa version plus standard public static void main(String[] args)

Écrire nos propres méthodes avec valeur de retour

Avec la décomposition, on a vu que c’est souvent utile de diviser un programme complet et plus petits sous-problèmes. Chacun serait une (ou plusieurs) méthode(s). Il faut alors savoir comment les déclarer dans nos programmes.

Signature de méthode

L’exemple de la leçon précédente, dans MainClass.java, montre comment déclarer les méthodes sans valeur de retour - comme void main() et void welcome(). C’est la même chose pour les méthodes avec valeur de retour, sauf qu’on remplace void par le type de retour désiré. Le format général est alors :

1
2
3
[type de retour] [nom de la méthode]() {
    // bloc de code
}

Corps de méthode

Les corps de méthode, les blocs de code entre les accolades {}, seront différents selon si le type est void (pas de valeur de retour) ou non.

1
2
3
void [nom de la méthode]() {
    // instructions
} // retour implicite à l'accolade fermante

1
2
3
4
void [nom de la méthode]() {
    // autres instructions
    return; // retour explicite sans valeur de retour
}

1
2
3
4
[type de retour] [nom de la méthode]() {
    // autres instructions
    return [valeur]; // retour explicite où valeur est du type de retour
}

Deux exemples

Le programme ci-dessous montre un exemple très simple (et banal) de deux méthodes avec valeur de retour.

Fichier : BasicReturn.java

1
2
3
4
5
6
7
8
9
10
11
12
13
String getName() {
    return "Dave3000";
}

int getMeaningOfLife() {
    return 42;
}

void main() {
    String name = getName();
    System.out.println("Bonjour, je m'appelle " + name);
    System.out.println("J'ai aussi un chiffre très important pour vous : " + getMeaningOfLife());
}

Remarquez qu’on a placé la méthode main à la fin du fichier. C’est possible de le faire, et souvent très naturel de le faire si vous avez planifié les différents modules de votre programme avant de commencer. Les développeurs tendent à mettre la méthode main soit au début, soit à la fin du fichier pour faciliter la lecture du programme.

Diagramme de flux pour une méthode avec valeur de retour

Ce qu’on a déjà appris sur les diagrammes de flux pour les méthodes s’applique, mais il faut maintenant :

1. Indiquer dans la définition de la méthode ce qui sera retourné
2. Utiliser dans l’algorithme principal ce qui est retourné suite à l’appel de la méthode

Voici le diagramme de flux pour le programme BasicReturn.java :

Le diagramme de flux nous aide à mieux voir la mécanique appel-retour. On voit quelque chose là qui n’est pas aussi apparent dans le code. Dans l’algorithme principal du diagramme de flux nous devons utiliser au moins deux instructions, soit :

• une pour l’appel de la méthode et
• une pour utiliser la valeur de retour.

Dans le code, tout ça se fait normalement sur la même ligne de code, en combinant plusieurs expressions (p. ex. : assignation et appel, affichage et appel) dans une seule instruction.

Notez aussi que l’appel précède toujours l’autre instruction dans le diagramme (comme durant l’exécution réelle du programme). Dans le code, ce n’est pas évident que ce soit le cas, car l’appel se trouve plus à gauche que l’autre instruction.

Structure générale pour l’utilisation d’une méthode avec valeur de retour

Tracer la séquence d’exécution

Peu importe si main se trouve au début ou à la fin du fichier, on commence toujours le programme à main. À part le déplacement de main, il n’y a rien de nouveau dans le diagramme de séquence d’exécution, sauf que :

• le fait de retourner à la même ligne que l’appel devrait faire plus de sens;
• on n’arrive pas à la ligne de l’accolade fermante s’il y a une instruction return; l’accolade fermante est un return implicite dans les autres cas.

1
2
3
4
5
6
7
9
10 -> 1
10 <- 2
11
12 -> 5
12 <- 6
13

Pour getName

1
10 -> 1

1
10 <- 2

Pour getMeaningOfLife

1
12 -> 5

1
12 <- 6

Diagramme de dépendances

Encore, pour ce diagramme on doit commencer à main et regarder quelles méthodes il appelle.

La nouveauté est qu’avec des valeurs de retour, on inclut le type de retour dans le bloc de la méthode. Plusieurs styles sont possibles, mais deux qui sont cohérents avec ce que nous voyons sont :

• [nom de la méthode]() -> [type de retour] … la flèche est semblable à ce qu’on utilise dans le diagramme de séquence d’exécution
• [nom de la méthode]() : [type de retour] … ce format ressemble à ce que vous voyez si vous ouvrez la panneau Structure (Outline en anglais) de VS Code.

Voici donc une version possible de ce diagramme. L’ajout des valeurs de retour nous indique que main dépend des valeurs String et int produites par les deux méthodes qu’il appelle.