Le code modulaire

Commençons avec un exemple simple¹ d’un programme décomposé, d’un programme modulaire.

Fichier : MainClass.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void main() {
    welcome();
    doStuff();
    bye();
}

void welcome() {
    System.out.println("Bienvenue dans mon programme!");
}

void doStuff() {
    System.out.println("On fait des choses utiles ici...");
}

void bye() {
    System.out.println("Bye!");
}

Dans ce programme, comme dans tout programme Java, le programme principal est dans la méthode main. Dans ce cas-ci, le programme principal est très simple. Il appelle trois autres méthodes, welcome, doStuff et bye. On comprend très bien la structure globale du programme. Par la suite, tous les détails du programme se trouvent dans les méthodes individuelles appelées par main. Même si ces détails devenaient plus complexes, la méthode main resterait simple et facile à lire.

Le diagramme de flux

Le même programme est représenté ci-dessous dans un diagramme de flux.

Notez qu’il y a plusieurs séquences d’instructions distinctes dans le diagramme de flux : une pour chaque méthode.

L’algorithme commence toujours avec l’ovale “Début” et se termine avec l’ovale “Fin”. Par contre, on a maintenant un nouveau type de bloc dans le diagramme - un appel de procédure :

Ce bloc envoie l’exécution du programme à la séquence d’instructions qui commence par le nom inscrit dans le bloc. Quand la séquence d’instructions de la méthode appelée est terminée, l’exécution est retournée au point de l’appel et continue le long des flèches.

On voit aussi que les ovales de début et de fin sont légèrement différents pour les procédures :

• le mot “Début” est remplacé par le nom de la méthode
• le mot “Fin” est remplacé par “Fin de [nom de la méthode]” ou “Retourne”

Tracer la séquence d’exécution programme

Chaque appel d’une méthode envoie l’exécution du programme à la signature de la méthode appelée et à travers ses instructions. Quand la méthode appelée se termine, l’exécution est retournée au point de l’appel pour continuer avec le reste du programme.

On peut le voir et le représenter comme suit.

À partir du code

On peut utiliser l’outil Python Tutor pour visualiser l’exécution du programme étape par étape afin de mieux comprendre la mécanique d’appel et de retour de méthodes.

Notez que le code est logiquement identique à celui ci-dessus mais que la version de Java disponible (Java 8) ne permet pas les simplifications de la syntaxe qu’on a avec Java 22. On a donc la déclaration explicite d’une classe et les mots clés static et public pour les méthodes.

Sans un tel outil, on peut tracer manuellement l’éxecution avec un diagramme de séquence d’exécution, soit :

• une liste des numéros de ligne exécutés dans l’ordre d’exécution;
• on indente vers la droite avec une flèche pour indiquer un appel de méthode et
• on revient à gauche avec une autre flèche pour indiquer le retour de la méthode.

Pour notre version de MainClass.java (avec la syntaxe simplifiée), le diagramme de séquence d’exécution serait :

1
2
3
4
5
6
7
8
9
10
11
1
2 -> 7  
     8
2 <- 9 
3 -> 11 
     12
3 <- 13 
4 -> 15 
     16
4 <- 17 
5 

1
2 -> 7

1
3 -> 11

1
4 -> 15

1
2 <- 9

1
3 <- 13

1
4 <- 17

Notez que l’appel et le retour reviennent à la même ligne dans le diagramme de séquence, soit 2 appel welcome et welcome retourne à 2, etc.

Dans Python Tutor, on sautait les lignes de signature durant l’appel et la ligne appelante lors du retour. C’est parce que nos procédures n’ont pas de paramètres et ne retournent pas de valeur en se terminant alors il n’y avait rien à visualiser pour ces lignes. On voit les paramètres et les valeurs de retour dans une prochaine leçon.

Notez aussi que durant l’exécution des méthodes appelées, les numéros de ligne sont identées au même niveau que la signature de la méthode afin de distinguer ces instructions des instructions de la méthode appelante.

À partir du diagramme de flux

On peut aussi tracer la séquence d’exécution à partir du diagramme de flux. On y ajoute manuellement plus de flèches!

Encore une fois, comme avec le diagramme de séquence d’exécution, l’appel et le retour se font à partir du même bloc dans le diagramme de flux.