Structures et boucles
Structures de conditions (choix)
Ces structures permettent au programme de prendre des décisions. Si certaines conditions sont
remplies alors le programme exécutera telle ligne de code plutôt qu'une autre.
Comment savoir si une condition est remplie ?
Vous vous souvenez des booléens ? C'est ici qu'ils interviennent. Si ce qu'on demande au
programme est vrai alors la condition est remplie sinon elle n'est pas remplie. Voici un exemple
concret.
Est-ce que Pauline est majeure ?
Vous ne savez pas son âge à cet instant
mais vous pouvez traduire cette condition par
ageDePauline >= 18.
Plus
tard, dans votre programme, vous apprenez que Pauline a deux ans. La condition devient alors
ageDePauline >= 18 devient 2 >= 18 ?
Nous sommes bien d'accord le résultat est faux et traduit en booléen false. La
condition n'est donc pas remplie.
& si nous avons plusieurs conditions à tester ?
Pas de problème ! Nous avons le && (et) et le || (ou) pour combiner
plusieurs conditions.
| Condition 1 |
|
Condition 2 |
RESULTAT |
| false |
&& |
false |
false |
| false |
&& |
true |
false |
| true |
&& |
false |
false |
| true |
&& |
true |
true |
|
|
| Condition 1 |
|
Condition 2 |
RESULTAT |
| false |
|| |
false |
false |
| false |
|| |
true |
true |
| true |
|| |
false |
true |
| true |
|| |
true |
true |
|
Si...et si...sinon...
En anglais if... else if... else.
/*************************************************
* IF
*************************************************/
//Une condition
int
ageDePauline = 2;
if
(ageDePauline >= 18){
System.out.println("La condition est remplie");
}
else
{
System.out.println("La condition n'est pas remplie");
}
if
(ageDePauline >= 0 && ageDePauline < 2){
System.out.println("C'est un bébé");
}
else if
(ageDePauline <= 2 && ageDePauline < 19){
System.out.println("C'est une enfant.");
}
else
{
System.out.println("C'est un adulte");
}
//Combinaison de plusieurs conditions
if
(ageDePauline >= 2 && ageDePauline <= 18){
System.out.println("Ce n'est plus un bébé et ce n'est pas un adulte non plus. Les
deux conditions sont remplies.");
}
if
(ageDePauline > 2 && ageDePauline <= 18){
System.out.println("Loupé... si on utilise && (et). Si l'une des conditions n'est
pas remplie alors l'ensemble des conditions sera faux.");
}
else
{
System.out.println("Pauline n'a pas un âge strictement supérieur à deux ans
(conditions non remplies) et elle est bien mineur (condition remplie)");
}
if
(ageDePauline > 2 || ageDePauline <= 18){
System.out.println("Bien joué... si on utilise || (ou). Si l'une des conditions est
remplie alors l'ensemble des condition sera vrai.");
}
else
{
System.out.println("Pauline n'a pas un âge strictement supérieur à deux ans
(conditions non remplies) mais elle est bien mineur (condition remplie)");
}
Si...et si...sinon... Version ternaire
La version ternaire est la version "raccourcie" du
if...else. Elle va plus vite à
écrire mais est plus difficile à lire.
/*******************************************************
* TERNAIRE
* résultat = condition ? condition vérifiée : condition non vérifiée;
*******************************************************/
int
age = 20;
//Le résultat de la variable isMajeur dépend de la condition
//age >= 18 ?
//Si oui, isMajeur = true
//Sinon, isMajeur = false
String
isMajeur = age >= 18 ? "Il est majeur" : "Il est mineur";
/* EQUIVALENT
String isMajeur1;
if(age >= 18){
isMajeur1 = "Il est majeur";
}
else{
isMajeur1 = "Il est mineur";
}*/
System.out.println("majeur si âge = 20 ? " + isMajeur);
age = 15;
isMajeur = age >= 18 ? "true" : "false";
System.out.println("majeur si âge = 15 ? " + isMajeur);
En fonction du cas
En anglais
switch(condition) case....
/*******************************************************
* SWITCH CASE
*******************************************************/
//Date du jour
LocalDate
date = LocalDate.now();
//Jour en français
String
dayInFrench = date.format(DateTimeFormatter.ofPattern("EEEE", Locale.FRANCE));
System.out.println(dayInFrench);
switch
(dayInFrench){
case
"lundi" :
System.out.println("pfffff le début de semaine, duuuur.");
break
;
case
"mardi" :
System.out.println("en cours...");
break
;
case
"jeudi" :
System.out.println("dire qu'avant, on sortait en soirée étudiante le jeudi.");
break
;
case
"samedi":
case
"dimanche":
System.out.println("C'est le week-end !");
break
;
default
:
System.out.println("En cours... mais par défaut !");
}
/*******************************************************
* SWITCH CASE
* DEPUIS JAVA 12 mais je suis en JAVA 11
*******************************************************/
/*switch(dayInFrench){
case "lundi" -> System.out.println("pfffff le début de semaine, duuuur.");
case "mardi" -> System.out.println("en cours...");
case "jeudi" -> System.out.println("dire qu'avant, on sortait en soirée
étudiante le jeudi.");
case "samedi", "dimanche" -> System.out.println("C'est le week-end !");
default -> System.out.println("En cours... mais par défaut !");
}*/
Boucles (répétition ou parcours d'un tableau/liste)
Ces structures permettent au programme de parcourir un tableau, une liste ou encore de répéter une
opération un certain nombre de fois. Le programme arrête alors l'exécution de cette boucle de
différentes manières :
- au bout d'un nombre de fois prédéfini (nommé souvent
i),
- à la fin de la liste ou du tableau,
- lorsqu'une condition (cf. section précédente) est remplie.
En programmation, nous avons le choix entre plusieurs boucles. Pour ma part, je préfère les boucles
for (pour). Nous avons moins de risques de tomber dans une boucle infinie et ainsi faire
planter le programme. Nous terminerons donc par celles-ci. Avant cela, les boucles tant que et
faire tant que.
Tant que...
En anglais while.
Ici, tant que la condition est vérifiée (tant que la valeur passée entre parenthèses renvoie
true), le programme exécute les instructions placées entre les accolades.
Si la condition n'est pas vérifiée, le programme ne passe pas du tout dans les accolades.
int
condition = 15;
/************************************************
* TANT QUE
************************************************/
int
j = 13;
while
(j > condition){
System.out.println("On ne passe jamais dans la boucle puisque la condition n'est pas
vérifiée.");
}
j = 18;
while
(j > condition){
System.out.println("On passe dans la boucle puisque la condition est vérifiée.");
//On décrémente j pour que la condition ne soit plus vérifiée.
j--;
//j = j-1;
System.out.println(j);
//Lorsque j atteindra 15, la condition ne sera plus vérifiée. On sortira de la boucle.
}
Faire... tant que...
En anglais do... while.
Ici, le programme exécute au moins une fois ce qu'il y a entre les accolades. Arrivé à la fin, il
continue d'exécuter ce qu'il y a entre les accolades tant que la condition est vérifiée (tant que la
valeur passée entre parenthèses renvoie true).
/************************************************
* FAIRE TANT QUE
************************************************/
j = 13;
do
{
System.out.println("Avec le do...while, on passe une fois dans la boucle même si la
condition n'est pas vérifiée.");
}
while
(j > condition);
j = 18;
do
{
System.out.println("On passe dans la boucle une première fois et après aussi puisque la
condition est encore vérifiée.");
//On décrémente j pour que la condition ne soit plus vérifiée.
j--;
//j = j-1;
System.out.println(j);
//Lorsque j atteindra 15, la condition ne sera plus vérifiée. On sortira de la boucle.
}
while
(j > condition);
Pour
En anglais
for....
La boucle for permet d'exécuter une portion de code
x fois où
x est
préalablement défini.
/************************************************
* POUR
************************************************/
//Pour un index nommé i ALLANT de 0 A 5 non compris (puisque <) PAR PAS DE 1 (i++)
for
(int i = 0; i < 5; i++){
System.out.println("Boucle for : "+i);
}
//Avec un tableau ou une liste
int[]
tab = {1,2,3,4,5,6,7};
ArrayList<Double>
list = new ArrayList<>();
list.add(1.1);
list.add(2.2);
list.add(3.3);
for
(int k=0; k < tab.length; k++){
int
el = tab[k];
System.out.println("Boucle for avec tableau : "+ el);
}
for
(
int
l=0; l < list.size(); l++){
Double
el = list.get(l);
System.out.println("Boucle for avec liste : "+ el);
}
Pour chaque élément
En anglais
for each... écrit
for dans le code.
La boucle for each permet de parcourir un tableau ou une liste sans avoir connaissance de la taille de
l'élément parcouru. Cela permet aussi de manipuler directement l'élément du tableau/liste sans passer
par l'étape
tab[index] ou
list.get(index).
/************************************************
* POUR CHAQUE ELEMENT
************************************************/
//for TYPE des éléments dans le tableau/liste NOMVARIABLE : ELEMENT_PARCOURU
for
(
int
elementTab : tab){
//foreach($tab as $elementTab)
System.out.println("Boucle foreach avec tableau : "+ elementTab);
}
for
(
Double
elementList : list){
System.out.println("Boucle foreach avec liste : "+ elementList);
}
Ruptures de séquence
Les ruptures de séquence permettent d'arrêter de manière prématurée l'exécution d'une boucle ou passer
une itération. En effet, parfois, dans un cas précis, la boucle ne doit pas avoir le même comportement
et c'est alors que les conditions d'arrêt entrent en jeu.
break
Si la condition est vérifiée, le mot clef
break permet de quitter la boucle.
/************************************************
* BREAK
************************************************/
for
(
int
k=0; k < tab.length; k++){
if
(k == 2){
break
;
}
int
el = tab[k];
System.out.println("On affiche l'élément parce que la condition k == 2 n'est pas
vérifiée : "+ el);
}
System.out.println("Dès que k==2, on sort de la boucle. Les autres éléments du tableau ne seront
pas traités.");
continue
Si la condition est vérifiée, le mot clef
continue permet de passer à l'itération d'après
sans exécuter le code qui suit.
/************************************************
* CONTINUE
************************************************/
for
(
int
k=0; k < tab.length; k++){
if
(k == 2){
System.out.println("Puisque k==2, on ne va pas afficher la phrase habituelle avec la
valeur. On passe notre tour : on \"continue\".");
System.out.println("ATTENTION");
System.out.println("Pour rappel, les indices des tableaux et listes commencent à 0 et nos
valeurs à 1. C'est pour cela que nous avons un \"décalage\".");
continue
;
}
int
el = tab[k];
System.out.println("On affiche l'élément parce que la condition k == 2 n'est pas vérifiée :
"+ el);
}
/!\ Les ruptures de séquence ne peuvent pas s'appliquer à une boucle for each.
heritage
