Les boucles et les structures conditionnelles

Objectifs : Comprendre l’utilité des boucles et connaitre le principe de chacune.

1. Les structures conditionnelles :

---

Les structures (branchements) conditionnelles sont conçues pour vérifier si une condition est vraie ou non et selon le résultat de sa véracité on effectue un traitement. Ce traitement sera exécuté 0 ou une seule fois.

Java a mis à notre disposition le if, if-else, le if-else-if-else, le if imbriqué et le switch.

a. Le if :

Structure :

             if (condition)
               {
                 //suite d’instructions
                  }

La condition peut être une comparaison de 2 variables de même type ou bien une comparaison d’une variable avec une autre valeur donnée, aussi de même type :

Dans les 2 figures, on remarque que la condition du if n’est pas vérifiée (3 diffèrent de 5).

Sauf que dans la première le résultat de l’exécution est un affichage (exécution de l’instruction System.out.println) alors que dans la deuxième le résultat est nul.

Explication :

Si après le if on ne met pas d’accolades, et si la condition du if est vérifiée automatiquement uniquement la première instruction s’exécutera, et le reste des instructions qui suivent s’exécuteront dans tous les cas quel que soit la véracité de la condition. Par contre avec la présence des accolades comme le montre la deuxième figure c’est tout le bloc qui sera exécuté ou pas.

b. Le if-else :

Structure :

          If (condition)
{
 //Suite d’instructions
}
else
{
 //Suite d’instructions
}

Même principe sauf que cette fois dans les 2 cas il y aura des instructions à exécuter :

c. if-else-if-else:

Il s’agit des if-else après le else, si une condition n’est pas vérifiée en passe au deuxième test et ainsi de suite :

Remarque :

• else ne peut pas exister sans être précédé par un if.
• Pour un seul if on ne peut pas avoir plus d’un else.
• Le nombre de else-if est sans limite, il faut juste faire attention à l’ordre.

d. Le if imbriqué :

C’est quand un if contient un autre if, donc si la condition est vérifiée on passe à la vérification de la condition suivante et ainsi de suite :

Ce if imbriqué peut avoir son else, des if-else-if-else et d’autres if imbriqués.

Remarque : On peut trouver un cas où la condition du if est affectation pas une comparaison :

Donc comme on voit dans l’exemple la condition n’est pas une comparaison == mais plutôt on voit le signe d’affectation = avec ça la condition a été vérifiée et le bloc à l’intérieur a été exécuté avec succès.

Explication :

Condition vérifiée = true. Et comme on le sait déjà, la valeur par défaut d’un attribut de type boolean est false.

Donc ici, if (y=x) se compose de 2 opérations, la première une affectation de la valeur de x (true) à la variable y et la deuxième la vérification de la valeur est true ou false.

1. y=x ;
2. if(y)if (true)

Dans un autre cas y a la valeur true ce qui fait que la condition est vérifiée et le bloc va être exécuté.

On va inverser la condition if (x=y) :

Donc voilà le résultat est logique, avec

1. y=x ;
2. if(y)if (true)

La condition n’est pas vérifiée donc le bloc à l’intérieur ne sera pas exécuté.

Remarque : ce type de condition n’est applicable qu’avec le type boolean.

e. Le switch :

Le switch s’utilise pour éviter les if-else-if-else, donc c’est plus pratique dans certain cas où l’on souhaite spécifier pour chaque valeur un traitement bien défini  et selon la valeur de la variable de test le traitement correspondant sera exécuté :

Structure :

    Switch(Nom_Variable)
{
     case valeur1 : // traitement1 ; break ;
     case valeur2 : // traitement2 ; break ;
     .
     .
     case valeurN : // traitementN ; break ;
     default : //traitement ; break ;
}

A travers quelques exemples on comprendra l’utilité de chaque mot réservé utilisé :

Les cases représentent les cas (case) envisagés des valeurs que peut prendre la variable.

Java commence par tester les valeurs de chaque case (par ordre de leurs apparitions) avec la valeur de la variable c, une fois la valeur retrouvée le traitement devant les : sera exécuté.

Le break : le break sert à sortir du switch comme ça il n’y aura plus une poursuite du test des autres case.

Selon le résultat on comprend que le default contient les instructions à exécuter si aucune valeur de case n’est la valeur de la variable c.

Donc comme on peut le voir, en éliminant le break, quand la valeur recherchée est retrouvée le traitement de la case correspondant est exécuté ainsi que les traitements des case qui succèdent jusqu’à la rencontre du break ou bien la fin du switch.

De même pour le default tant que il n y a pas de break il continue l’exécution des instructions.

Aussi comme la variable peut être comparée avec des valeurs, elle peut de même être comparée avec d’autres variables de même type, mais pas avec n’importe quelle variable :

L’erreur qu’on voit est générée suite à la déclaration d’une variable non constante. Donc pour corriger on fera comme suit :

En cas de duplication d’une même valeur dans plus d’une case une erreur de compilation s’affichera :

Aussi le switch ne tolère pas tout type de variable :

Remarque : Avec switch, on ne peut utiliser que les variables de type byte, short, int et char.

2. Les boucles :

---

Si on a besoin de  répéter certaines instructions plusieurs fois, au lieu de les écrire X fois et par fois le nombre X n’est pas connu à l’avance mais dépend d’une condition dans ces cas on fera recours au boucles qu’on va voir tout de suite.

Java a défini 4 boucles :

• for
• whil
• do
• foreach

a. La boucle for :

Cette boucle permet de répéter le mm traitement X fois à condition que le X soit connue.

Structure :

for (int i=0 ;i<nombre_iteration ;i++)
{
//suite d’instructions
}

i : le compteur

i=0 : initialisation du compteur, valeur de départ

i <nombre_iteration : condition d’exécution. Si cette condition n’est plus vérifiée, la boucle s’arrête

i++ : incrémentation du compteur après chaque itération

Exemple :

Donc voilà on a affiché le même message 5 fois avec la valeur de i qui change à chaque fois.

On aurai pu écrire for( int i=1 ;i>=5 ;i++) pour avoir le même résultat.

La boucle for peut contenir aussi une structure conditionnelle comme elle peut contenir une autre boucle for ou autre :

Pour chaque valeur de i on exécute la deuxième boucle for et pour chaque valeur de j on teste la condition if.

Tant que i<5 et tant que j>i on exécute le bloc d’instructions.

On remarque qu’à chaque incrémentation de i le nombre d’itération de la deuxième boucle décrémente suite à la condition j>i

Autres propriétés de cette boucle :

• Le premier champ, celle de l’initialisation peut être vide si on a déclaré la variable à utiliser en dehors de la boucle.
• Le deuxième champ, celui où on met la condition peut être vide mais ça va engendrer une boucle infinie, l’exécution du traitement se répètera jusqu’à atteindre le time out du système, de même si on met true à la place de la condition, par contre si on met false une erreur de compilation s’affichera nous informant que dans ce cas le traitement ne sera jamais atteint.
• Ce champ-là peut aussi contenir plus d’une condition séparées par && ||
• Le dernier champ dans lequelle on met le pas du compteur (incrémentation/décrémentation/affectation) peut aussi être vide sachant qu’il y aura exactement 3 cas d’exécution : soit une boucle infinie si la condition est vérifiée sinon si la condition est vérifiée et que dans le bloc d’instructions du for il y a une instruction qui fait changer la condition et à un moment donné arrêter les itérations.
• Elle peut contenir plus d’un compteur mais en suivant ces conditions-là :
  • Dans la première partie si on souhaite utiliser plus d’un compteur, on doit vérifier le temps. S’ils sont de même types alors la déclaration et l’initialisation peuvent se faire dans l’entête du for sinon la déclaration se fait à l’extérieur, en dehors de la boucle et seulement l’initialisation se fait dans l’entête.
  • Pour la dernière partie réserver au incrémentation ou décrémentation, elle ne peut inclure plus qu’une instruction

b. La boucle while :

Cette boucle s’utilise pour répéter un traitement X fois, ce X n’est pas reconnue à l’avance mais dépend d’une condition.

Le traitement peut s’exécuter 0 ou plusieurs fois car on commence par la vérification de la condition.

On peut la lire comme suit : tant que la condition est vérifiée faire exécuter le traitement.

Structure :

while(condition)
         {
           //suites d’instructions
        }

On commence par exemple où la condition est false initialement :

La valeur de x n’a pas changé car il y a eu un test sur la condition qui est initialement fausse avant d’entamer l’exécution du bloc interne à la boucle.

Changeons un peu la condition pour qu’elle soit initialement vraie :

Donc voilà la condition est true dès le début, l’exécution des instructions se répètent jusqu’à non satisfaction de la condition d’où on constate que la valeur de x a changé 4 fois puis il y a eu l’exécution de l’instruction d’affichage de y écrite en dehors de la boucle.

c. La boucle do :

Même principe que la boucle while.

Remarque : contrairement à la boucle while, le traitement s’exécute au moins une fois car la première exécution se réalise avant la vérification de la véracité de la condition.

On peut la lire comme suit : faire exécuter le traitement tant que la condition est vérifiée

Structure :

do
     {
       //suite d’instructions
    }
    while(condition)

Prenons le même exemple précèdent :

Prenons le même exemple précèdent :

On remarque bien que la condition x>y est initialement fausse mais vu que le principe de la boucle do est d’exécuter une première fois le traitement puis tester la condition pour les prochaines itérations. Cette boucle pour cette exemple à générée une boucle infinie ar à chaque fois le nombre de x incrémente ce qui laisse la condition toujours vraie après la première itération.

On peut arrêter l’exécution par cette icone le carré rouge pointé par la flèche.

Et puisqu’il s’agit d’un int l’incrémentation continue jusqu’à atteindre la borne supérieur de la plage du type entier puis se refait pour atteindre la marge inférieure (marge négative) et ça recommence jusqu’à atteindre le timeout du système, comme le montre la figure ci-dessus :

Et voici un autre exemple un peu plus raisonnable avec conditions d’arrêts après 4 itérations :

Une boucle peut en imbriqué contenir une même boucle, d’autres boucles (while, for, do) ou des structures conditionnelles (if, switch).

Maintenant on va voir la différence entre 3 instructions le break comme a vu avec la boucle switch, le continue et le System.exit(0) qu’on va connaitre tout de suite :

Comme le montre l’exécution, le break permet de sortir de la boucle et continuer l’exécution du reste du programme.
Une fois on tombe sur la première valeur impaire de, java sort de la boucle et exécute l’instruction d’affichage du message  » terminé « +x
Si on remplace le break par continue on aura :

Une boucle infinie de l’affichage de la première valeur trouvée impaire de x. 

Explication : 

Le continue permet de sauter à la prochaine itération de la boucle, autrement dit quand x est à la valeur 7 l’exécution du bloc else à commencé l’affihage du message « impaire 7 » puis le continue nous remet à la condition de la boucle while et puisque 7 est toujours un nombre pais c’est toujours le bloc du else qui sera exécuté donc boucle infinie.

Alors que si on élimine le continue, on aura :

On fera une exécution à la main pour mieux comprendre le fonctionnement de la boucle :

Pour toute valeur de x : La valeur 8 paire : bloc du if à exécuter ==> nouvelle valeur de x : 7

La valeur 7 impair : bloc du else à exécuter ==>  nouvelle valeur de x : 6

Puis la valeur 6 et ainsi de suite jusqu’à ce que x atteigne la valeur 1 dans ce cas la condition du while(x>y) n’est plus vérifiée et on sort de la boucle pour continuer l’exécution du programme.
Quant au System.exit(0) :

System.exit(o) contrairement à break et continue sert à sortir totalement de la méthode, c’est pour cette raison QUE la dernière instruction est system.out.printIn(« terminé »+x) ; 

f. Le foreach :

Cette boucle est une boucle for améliorée, elle est utilisée pour parcourir les types composés (tableau, liste, vecteur), on verra un exemple quand on attaquera le tuto des types composés, jusqu’ici limitons nous à son utilité et sa structure :

Structure :
for( Type_ElementNom_variable : Nom_Structure)
{
//Suites d’instructions
}

Nom_Structure : le tableau, la liste ou le vecteur qu’on a créé et rempli
Type_Element : le type des éléments contenus dans le Nom_Structure
Nom_Variable : Variable temporaire à utiliser pour représenter les éléments du Nom_Structure

Remarque : La boucle foreach ne sert qu’à afficher le contenue de l’enregistrement saisi, donc même si on écrit des instructions de modifications des éléments, ça ne va rien changé car la modification sera faite sur la Nom_Variable qui prend juste une copie des éléments pour les afficher donc un changement sur la valeur de cette variable n’entraine pas une modification sur l’élément qu’elle représente.

Voilà on a terminé avec les boucles et les structures conditionnelles, je vous donne rendez-vous pour un prochain qui sera consacré aux types composés et leurs manipulations.

Merci de nous avoir fait confiance.

Je vous invite à consulter quotidiennement le site d’Odellya pour profiter des prochains tutoriels qui seront bientôt à votre disposition.