Les bases du Java – Les boucles (4/5)

Posted on Posted in Beginner, Java, Tous les articles

Salut c’est Sébastien, on se retrouve aujourd’hui pour une nouvelle vidéo sur le Java. Aujourd’hui on va parler des boucles, ça va nous permettre d’exécuter plusieurs fois le même code. Vous allez voir que ça nous sera très utile, c’est parti !

La boucle While

Alors la première boucle qu’on va voir aujourd’hui ce sera le « while », qui a la syntaxe suivante :

// La boucle while
while()
{

}

Alors comment ça se présente ? Le mot « while » signifie « tant que ». Ainsi, tant que la solution qui est entre parenthèses sera vraieon exécutera le code qui se trouvera entre les accolades.

Alors par exemple, vous allez créer une variable « i » de type entier qui va valoir 0 au début. Dans la condition on va écrire, tant que « i » est inférieure à 10 alors affiche la valeur de la variable « i ». A chaque tour de boucle, la valeur de la variable sera donc affichée.

Important : il ne faut pas oublier de mettre une condition d’arrêt à notre boucle. Ici on exécute le code tant que « i » est inférieure à 10, sauf que comme « i » vaut 0, si on ne fait rien, elle vaudra toujours 0 et la condition sera toujours vraie. Le problème est que l’on va rentrer dans une boucle infinie et que le programme ne s’arrêtera jamais. Il faut donc bien penser à ajouter « i++ »

« i++ » va nous permettre d’incrémenter « i » et à chaque fois que l’on va passer dans la boucle, « i » va s’incrémenter de 1.

Ce qui nous donne en java :

while (i < 10)
{
	System.out.println("La variable i vaut : " + i);
	i++;
}

On va exécuter tout de suite pour voir ce que cela nous donne.

 

Alors qu’est-ce qui se passe ? Dans un premier temps « i » vaut 0, on rentre dans la boucle et on affiche la variable « i » qui vaut toujours 0. Ensuite, on passe à la ligne suivante qui va incrémenter la variable « i » donc « i » maintenant vaut 1.  Quand on arrive à la fin du « while » on retourne au début et on regarde si la condition est vraie.  La condition est toujours vrai car « i » vaut 1 et vous avez compris le principe ! Le code sera exécuté jusqu’à ce que « i » vaille 10. Si « i » vaut 10, comme 10 n’est pas strictement inférieur à 10, on va sortir de la boucle et le code suivant sera exécuté.

Dans cet exemple, on vérifiait la condition avant de rentrer dans le « while » mais il existe une petite variante qui est le « do…while ».

La boucle Do…while

Cette boucle a la syntaxe suivante :

// La boucle do...while
int i = 0;
do
{

} while (i < 10);

Ici on va donc exécuter le code entre accolades, tant que la condition est vraie. Pensez bien à remettre la variable « i » à 0 juste avant, car avec la boucle précédente on l’a incrémenté à 10.

La différence avec la boucle « while » est qu’ici, on va exécuter ce qui se trouve entre  accolades au moins une fois même si la condition est fausse et on va recommencer si la condition est vraie. La petite nuance est que dans le « do » on va passer au moins une fois, alors que dans le « while » si la condition est fausse dès le début, on n’exécutera jamais ce code.

Faisons un test : si par exemple on retire le « int i = 0 » alors « i » vaudra 10. La condition du « while » sera donc fausse mais le code sera exécuté au moins une fois.

// La boucle do...while
// int i = 0;
do
{
    System.out.println("DO WHILE - La variable i vaut " + i);
    i++;
} while (i < 10);

Si on exécute ce code on aura le résultat suivant :

On voit bien que la variable « i » vaut 10 donc que la condition est fausse mais que le code à quand même été exécuté.

Si on remet « i » à 0 et que l’on exécute :

// La boucle do...while
int i = 0;
do
{
    System.out.println("DO WHILE - La variable i vaut " + i);
    i++;
} while (i < 10);

On retrouve le même comportement que le « while ».

 

La boucle For

Enfin la dernière boucle qui existe en Java est la boucle « for ». Voici sa syntaxe :

// La boucle for
for (int j = 0; j < b; j++)
{

}

Entre parenthèses on :

  • Initialise une variable, par exemple « j » de type entier, à 0. On fini avec un « ; »
  • Après le « ; », on va mettre la condition, par exemple tant que « j » est inférieur à 10. On fini avec un « ; »
  • Après le deuxième « ; » on va incrémenter notre variable « j » à chaque tour de boucle « for » donc « j++ »

L’avantage par rapport à la boucle « while » c’est que dans le corps de la boucle on a pas besoin d’incrémenter notre variable « j » vu que c’est fait automatiquement dans le « for ». On va exécuter ça :

for (int j = 0; j < b; j++)
{
	System.out.println("FOR - La variable j vaut : " + j);
	res += a;
}

On a bien notre variable « j » qui s’incrémente de 0 à 9 et qui s’affiche à chaque tour de boucle :

 

Donc la on va faire un petit exercice pour voir si vous avez compris.  Je vais vous donner un entier « a » qui vaut 5. Un autre entier « b » qui vaut  7. Ce que vous allez faire, en utilisant la boucle « for », c’est de multiplier 5 par 7 donc  5 x 7 MAIS en utilisant que des additions.

Donc je vous invite à le faire sur Eclipse en mettant la vidéo pause tout de suite et moi je passe à la correction ! J’espère que vous allez faire l’exercice 🙂

La solution

Alors comment faire ça ? On veut remplacer notre multiplication par à plusieurs additions, donc on veut faire 5 x 7. Ainsi on va faire 5 + 5 + 5 + 5 + 5 + 5 + 5 (7 fois). Tout d’abord on va initialiser notre variable « j » à 0. On va dire tant que « j » est inférieur à 7 on va exécuter la boucle « for ». J’espère que vous avez compris l’astuce 🙂

Nos variables

Initialisons une variable dans laquelle on va stocker le résultat. Créons un entier « res » de type entier.

int a = 5;
int b = 7;
int res = 0;
Notre boucle for

On écrit une boucle « for » qui va s’exécuter 7 fois. Dans notre boucle, le résultat sera égal à lui-même plus la variable « a ». En effet, la boucle va s’exécuter 7 fois et à chaque tour de boucle, on va ajouter 5 au résultat. Cela va bien nous donner le résultat de la multiplication à la fin.

int a = 5;
int b = 7;		
int res = 0;
		
for (int j = 0; j < b; j++)
{
	System.out.println("FOR - La variable j vaut : " + j);
	res += a;
}
		
System.out.println("Le resultat : " + res);

Si on exécute, le résultat vaut bien 35 et 5 * 7 = 35.

 

Conclusion

C’est tout pour aujourd’hui, on a vu les boucles. On a vu vraiment les bases avec des exercices simples, qui ne sont pas vraiment concrets, vous n’allez jamais faire d’addition dans des boucles pour remplacer une multiplication classique 😉 La le principe c’était de voir vraiment comment ça fonctionnait. Encore une fois on passera à des exemples un petit peu plus concret dans les vidéos dédiés aux exercices. Si vous voulez vous tenir informer de tout ça, vous pouvez vous abonner à la chaîne, si ce n’est pas encore fait. En attendant je vous dis à la prochaine, salut tout le monde !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *