Projet 3 : Structures de contrôle de flux

Ce projet va nous permettre d'approfondir les structures de contrôle de flux et ne plus avoir de programmes dont l'exécution est simplement linéaire. Nous allons construire un simple programme qui permettra de découvrir les structures de test ainsi que les boucles. Nous n'allons bien entendu pas utiliser toutes les nouvelles instructions que l'on vient de voir. Nous continuerons à approfondir l'utilisation du programme Eclipse et comme d'habitude, nous vous conseillons de lire le chapitre 3 du tutoriel avant de commencer ce projet pratique.

Créer le projet

Nous allons donc ajouter notre nouveau projet dans Eclipse en faisant un clic droit dans l'Explorateur et en cliquant sur le menu New > Project. Complétez ensuite le champ Project Name avec Projet3.

Ensuite, on crée notre classe principale en cliquant avec le bouton droit sur le projet dans l'explorateur et ensuite cliquez sur le menu New > Class. Ensuite donnez comme nom (name) à votre classe Projet3 et cochez la case public static void main(String[] args) pour qu'Eclipse place la méthode main pour vous.

Paramétrer le style du code

Les accolades ne sont pas automatiquement placées toutes seules sur une ligne comme nous l'aimons bien. Nous allons tout de suite y remédier en changeant le style automatique du code. Cliquez sur le menu Window > Preferences ..., sélectionnez ensuite la rubrique Java > Code Style > Formatter et vous tombez sur la fenêtre montrée ci-dessous.

Vous pouvez maintenant changer le style de codage en Java Conventions, ou Eclipse, ... Vous pouvez également créer votre propre style en cliquant sur New... et c'est ce qu'on va faire maintenant. Il faut donner un nom au nouveau style, puis on peut repartir d'un style existant. Créons le style uko en partant du style Java Conventions.

Une fois que vous aurez cliqué sur OK, une fenêtre avec tout plein d'onglets s'ouvre et vous permet de paramétrer votre style super précisement pour chaque type d'instruction. Nous n'allons pas décrire toutes les possibilités ici, essayez par vous-même selon votre style (un aperçu en temps réel vous est proposé pour chaque modification). Vous pouvez également télécharger le style UKO et l'ajouter avec le bouton Import ....

Supprimez maintenant la classe Projet3 que l'on vient de créer dans le projet en cliquant avec le bouton droit dessus dans l'Explorateur puis en cliquant sur le menu Delete. On va maintenant recréer la classe Projet3 avec le style UKO et voici ce que vous devriez voir dans l'éditeur :

Le projet

Que voulons-nous faire ? C'est assez simple, il faudrait afficher dans la console, en continu, des astérisques (*). Nous aimerions en afficher une sur la première ligne, ensuite deux, puis trois ... Mais lorsqu'on arrive à dix astérisques, le nombre doit diminuer. Donc, dix astérisques sur la dixième ligne, puis neuf sur la onzième, ensuite huit, ... Et lorsqu'on retombe à une astérisque, on recommence à augmenter. Ce qui donne :

*
**
***
****
*****
******
*******
********
*********
**********
*********
********
*******
*****
****
***
**
*
**
***
****
*****

Comment faire ceci ? On vient de dire qu'on voulait que ça continue indéfiniment, on va donc utiliser une boucle while, et on va lui donner comme condition le litéral true ainsi, elle ne s'arrêtera jamais étant donné que true ne sera jamais faux. On a donc une boucle infinie.

Il faut ensuite garder en mémoire le nombre d'étoiles à afficher sur la ligne actuelle, on initialise donc une variable nb de type int qui contient 1 au départ. Ensuite, dans la boucle while, on va imbriquer une boucle for qui affiche une ligne d'étoiles. On utilise la boucle for car on sait combien de fois on doit boucler et ainsi, on évite le risque d'une boucle infinie. Dans la boucle for, on utilise System.out.print pour ajouter à la console un astérisque et après la boucle, on ajoute un System.out.println pour aller à la ligne.

Après chaque ligne d'étoiles, il faut augmenter le nombre d'astérisque par ligne et donc, on utilise nb++. Si on lance le programme maintenant, le nombre de lignes va augmenter à chaque fois. On n'a pas encore tenu compte de la condition qui dit qu'il faut diminuer le nombre d'astériques une fois que celui-ci a atteint 10. Une fois le programme lancé, puisqu'on a volontairement mis une boucle infinie, il ne s'arrêtera jamais, il faut le faire manuellement en cliquant sur le carré rouge en haut de la console.

Après l'affichage d'une ligne, il faut donc vérifier la valeur de nb, dès que nb atteint 10, il faut enlever une étoile par ligne, et dès que nb retombe à 1, il faut ajouter une étoile par ligne. Pour faire cela, on va utiliser une nouvelle variable increment qui contiendra +1 ou -1. Il suffira de changer sa valeur grâce à un test après chaque ligne en utilisant une instruction if-else.

Comme il n'y a qu'une instruction dans le bloc if, on n'est pas obligé de mettre les accolades, mais nous, on préfère toujours en mettre, c'est une question de style. L'avantage, c'est que le code est plus clair et que si on veut modifier le bloc if, les accolades sont déjà là.

Maintenant, il suffit de déclarer et d'initialiser la variable increment avant la boucle while et de changer la ligne nb++ par nb += increment. Une fois le programme lancé, vous devriez voir dans la console le motif voulu défiler.

Pour aller plus loin

Essayez-donc de changer le programme en remplaçant l'instruction if-else par une instruction switch. Essayez également en n'utilisant que des boucles while ou alors que des boucles for. Enfin, essayez de représenter le même motif mais uniquement avec un nombre pair d'astérisques par ligne. On commence avec 2 astérisques, puis 4, 6, 8, 10, puis on redescend, 8, 6, ... :

**
****
******
********
**********
********
******
****
**
****
******

L'opérateur modulo pourrait vous être utilie pour résoudre ce problème. Pour rappel, n % 2 vaut 0 si n est pair et vaut 1 si n est impair.

Résumé des points importants

• Pour répéter un bloc de code, il faut utiliser les structures répétitives, en Java il existe les boucles while, do et for ;
• while et do sont utilisés lorsqu'on ne sait pas combien de boucles on va faire. La boucle do est parcourue au minimum une fois et la while au minimum aucune fois. La boucle for est utilisée dès qu'on connait le nombre de boucles à faire ;
• Pour prendre des décisions, on utilise les structures alternatives, elles permettent d'exécuter des blocs de code sous certaines conditions ;
• En Java, il existe les structures if-else et switch. switch est utilisé lorsque beaucoup de cas sont présents (plus de deux) sinon, on utilise if-else.

N'hésitez pas à télécharger le projet.

Testez vos connaissances

Nous voilà déjà au bout de ce troisième projet pratique. Nous vous proposons maintenant de vous tester en faisant les divers exercices du troisième chapitre. Vous pourrez ensuite continuer le tutoriel et passer au quatrième chapitre qui introduit la notion d'objet.

Pour tout problème, toute remarque, rendez-vous sur le forum consacré aux exercices pratiques.