Les boucles

Décortiquons précisément ce qui se passe dans une boucle.
Pour cela, nous allons voir comment elle se forme.

Une boucle commence par une déclaration. Ici : while qui veut dire, à peu de chose près, TANT QUE.
Ensuite, nous avons une condition. C'est elle qui permet à la boucle de s'arrêter. Une boucle n'est pratique que si nous pouvons la contrôler, et donc lui faire répéter une instruction un certain nombre de fois. C'est à ça que servent les conditions.
Puis nous avons l'instruction. C'est ce que va répéter notre boucle ! Dans une boucle, il peut y avoir une ou plusieurs instructions.

Remarque : il peut même y avoir des boucles, dans une boucle...

À ce stade, la boucle va tester la condition, et en fonction de celle-ci, va recommencer ou s'arrêter.

Un exemple concret est toujours le bienvenu... Voici comment une boucle de type while se fait en Java.

D'abord, réfléchissons au "comment notre boucle va travailler". Pour cela, il faut déterminer notre exemple.
Nous allons afficher "bonjour", <un prénom> que vous allez taper à l'écran, puis vous demanderez si vous voulez recommencer. Pour réussir ceci, il nous faut une variable pour recevoir le prénom, donc de type String, et une variable pour récupérer votre réponse et là, plusieurs choix s'offrent à nous : soit un caractère, soit une chaîne de caractères, soit un entier. Ici, nous prendrons une variable de type char.
Et c'est parti !

Code : Java

Avant tout, vous avez dû cligner des yeux sur cette ligne "reponse = sc.nextLine().charAt(0);". Rappelez-vous comment on récupère un char avec l'objet Scanner. Nous devons récupérer un objet String et ensuite prendre le premier caractère de celui-ci ! Eh bien cette syntaxe est une contraction de ce que je vous avais fait voir auparavant .


Détaillons un peu ce qui ce passe.
Dans un premier temps, nous avons déclaré et initialisé nos variables.
Ensuite, la boucle teste la condition qui nous dit : "Tant que la variable reponse contient OUI, on exécute la boucle". Celle-ci contient bien la chaîne OUI, donc nous entrons dans la boucle. Rappelez-vous qu'on teste l'égalité des conditions avec un double égal ==.
Puis c'est l'exécution des instructions, dans l'ordre où elles apparaissent dans la boucle.
Et à la fin, c'est-à-dire à l'accolade fermante de la boucle, le compilateur retourne au début de la boucle.



Voilà. C'est pas mal, mais il y a un petit problème, dans ce programme... Vous ne voyez pas ? Oh ! Je suis sûr qu'il y a des petits malins qui se sont amusés à mettre autre chose que 'O' ou 'N' en "reponse". Ces petits filous-là ont dû remarquer que nous sortons de la boucle si on tape autre chose que 'O'... Essayez de trouver comment pallier à ce problème....
Il faudrait forcer les utilisateurs à ne tapez que 'OUI' ou 'NON'... Mais non, pas en leur mettant un couteau sous la gorge, bande de barbares !
Avec une boucle !
Comment faire ? C'est très simple, vous allez voir ! Il suffit, comme je l'ai dit plus haut, de forcer les utilisateurs à rentrer soit 'NON'soit 'OUI' ! Avec un while ! Mais cela sous-entend de réinitialiser notre variable reponse à ' ' (caractère vide).
Nous allons utiliser ici la méthode. Occupons-nous de la condition de notre boucle, maintenant. Il faut répéter la phase "Voulez-vous réessayer ?" tant que la "reponse" donnée n'est pas 'OUI' et 'NON' : voilà, tout y est.
On appelle ce genre de condition des conditions multiples. Vous avez vu les opérateurs logiques au chapitre 2, normalement... (et == &&) Nous en reparlerons dans le prochain chapitre...

Voici notre programme dans son intégralité :

Code : Java



Vous pouvez tester ce code (c'est d'ailleurs vivement conseillé) : vous verrez que si vous ne rentrez pas la bonne lettre, le programme vous demandera sans cesse votre réponse !





Voilà un autre exemple de boucle infinie, encore plus flagrante :

Code : Java
Si vous lancez ce programme, vous allez voir une quantité astronomique de coucou 1 fois !!, car, dans cette condition, a sera toujours inférieur à b.
Si nous voulions faire en sorte que ce programme fonctionne comme il faut, nous aurions dû rajouter une instruction dans le bloc d'instructions de notre while, pour changer la valeur de a à chaque tour de boucle...

Comme ceci :

Code : Java

Ce qui nous donnerait cela :



Notre a a bien augmenté de 1 à chaque tour. Et si vous me dites que vous n'avez jamais vu a++; je vous renvoie illico au second chapitre ==> sous chapitre 3 !

Qu'en dites-vous ? Pas trop mal, non ? Je dirais même bien !



Vous auriez pu aussi utiliser cette syntaxe :
Code : Java

Rappelez-vous de ce dont je vous parlais au chapitre précédent sur la priorité des opérateurs. Ici, l'opérateur '<' a la priorité sur l'opérateur d'incrémentation '++'. Pour faire court, la boucle while teste la condition et ensuite incrémente la variable a. Par contre, testez ce code :
Code : Java

Vous devez remarquer qu'il y a un tour de boucle en moins !
Eh bien, avec cette syntaxe, l'opérateur d'incrémentation est prioritaire sur l'opérateur d'inégalité (ou égalité). C'est-à-dire que la boucle incrémente la variable a et, seulement après avoir fait cela, elle teste la condition !



Avant d'aller voir un autre type de boucle, j'insiste sur le fait que vous devez bien réfléchir à vos conditions, ainsi qu'à vos variables, avant de lancer une boucle, sous peine de ne jamais y rentrer, ou comme on l'a vu, de faire une boucle infinie !
Bon, continuons avec la boucle do{...}while().

Vu que je viens de vous expliquer comment marche une boucle while, je ne vous expliquerai que très brièvement la boucle do... while.


Bien entendu. En fait, ces deux boucles ne sont pas cousines, mais plutôt frangines (soeurs, si vous préférez...). Dans le fonctionnement, elles sont identiques, à deux détails près. Soeurs, mais pas jumelles, quoi...

Première différence

La boucle do... while s'exécutera au moins une fois, contrairement à sa soeur. C'est-à-dire que la phase de test de la condition se fait à la fin. Car la condition se met après le while.

Deuxième différence

Différence de syntaxe. Et elle se situe après la condition du while.
Exemple :
Code : Java
Vous voyez la différence ? Oui ? Non ?


Mis à part ces deux éléments, ces boucles fonctionnent exactement de la même manière. D'ailleurs, nous allons refaire les deux programmes de la boucle while ci-dessus, avec une boucle do... while. C'est parti !

Code : Java

Et faites-moi confiance : ça marche ! Mais toujours le même problème de réponse... Voici donc le code complet :

Code : Java

Vous voyez donc que ce code ressemble beaucoup à celui utilisé avec la boucle while, mais avec une petite subtilité. Avec celui-ci, plus besoin de réinitialiser la variable reponse, puisque, de toute manière, la boucle s'exécutera au moins une fois !

Normalement, vous devriez avoir compris du premier coup ! On va pouvoir se lancer sur la dernière boucle : la boucle for.

Cette boucle est un peu particulière, puisque qu'elle prend tous ses attributs dans sa condition, et agit en conséquence. Je m'explique : jusqu'ici, nous avions fait des boucles avec :

• déclaration d'une variable avant la boucle
• initialisation de cette variable
• incrémentation de celle-ci dans la boucle.

Eh bien on met tout ça dans la condition de la boucle for, et c'est tout. Mais je sais bien qu'un long discours ne vaut pas un exemple, alors voilà une boucle for sous vos yeux ébahis :

Code : Java
Et ça nous donne :




Je vous fais la même remarque que pour la boucle while concernant les accolades...
Nous pouvons aussi tourner la boucle dans le sens inverse. C'est-à-dire qu'au lieu de partir de zéro pour aller à 10, nous allons aller de 10 pour atteindre 0. Comme ceci :
Code : Java

Ce qui nous donne :





Bon : vu que nous sommes de bons ZérOs et que nous n'aimons pas les fautes d'orthographe, nous voulons mettre "ligne" au pluriel lorsqu'il nous en reste plusieurs à écrire, et au singulier lorsqu'il nous en reste 1 ou moins ! Il va de soit que nous allons utiliser les conditions pour réussir ce tour de force.
Je vous laisse réfléchir .

Secret (cliquez pour afficher)




Un petit détail, tout de même... Ici, nous avons utilisé un entier bien défini pour gérer nos boucles, tel que 0 ou 10. Nous pouvons tout aussi bien faire les mêmes boucles avec une variable en guise d'attribut. Là, vous commencez à apercevoir leur intérêt. Ne vous inquiétez pas : vous allez voir tout ceci plus tard. Et plus précisément dans le chapitre sur les tableaux, qui arrive à pas de loup !

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int i = 0, nbre = 0;
    while(i <= 9)
    {
     for (int j = 0; j < 10; j++)
        nbre++;
 
 
       i++;
    }
  System.out.print(nbre);

1
2
3
4
5
6

int i = 0, int nbre = 10;
 
while (i < 10)
 nbre *= 10;
 
System.out.println(nbre);

1
2
3
4
5
6

int nbre = 0;
 
for(int i = 0; i < 10000000; i++)
   nbre++;
 
System.out.println("nbre");