Finalisons notre boîte à outils du développeur pour le projet Epicrafter’s Journey. Marc est une nouvelle fois de retour et il vient faire le point avec vous !
Alors te voilà capable de
déclarer, initialiser une variable et lui affecter une valeur ;
afficher un texte dans la console ;
appeler une fonction.
C’est bien !
Jenny intervient :
Prêt à passer à la suite ?
Marc ne vous laisse pas le temps de répondre :
On y est presque Jenny ! Les variables et les fonctions ont été vues. Cependant ce n’est pas suffisant encore.
Interrogatif, vous réagissez :
Pourquoi ?
On pourrait comparer les fonctions à des machines sur une chaîne de montage. Actuellement tu arrives à construire la machine c’est-à-dire écrire une fonction. Tu arrives aussi à faire en sorte que le tapis amène des éléments à ta machine et que quelque chose en sorte, c’est-à-dire les paramètres d’entrées et la valeur de sortie.
Mais voilà, ta machine en elle-même ne fait pas grand-chose ! On va arranger ça avec deux points fondamentaux : les structures conditionnelles et les structures itératives.
Vérifiez une condition
Nous avons terminé le chapitre précédent avec un point en suspens mais qu’est-ce que l’instruction if( ) { } ?
Vous nous avez dit que c’est une condition, c’est-à-dire ?
En français, la traduction littérale du mot anglais if est si. Nous sommes en train d’évoquer une éventualité. Exemple, s’il fait beau demain, j’irai à la plage. Notre action est alors conditionnée par le temps qu’il fera.
En programmation, la condition revêt exactement le même caractère. En fonction d’un certain critère (évidemment pas le temps qu’il fait, quoique… ) alors nous réaliserons certaines instructions.
Mais cela ne s’arrête pas là. Complétons notre exemple. S’il fait beau demain, j’irai à la plage sinon j’irai au cinéma. Ce deuxième scénario, issu de la non-validation du critère, est programmable grâce au mot-clé else.
Enfin, en programmation, la condition doit être une valeur de type boolean (car oui tout est typé).
Pour obtenir cette valeur booléenne nous allons généralement utiliser des opérateurs de comparaison comme == (égal à) ou != (différent de). Illustrons :
public static void chiffreEgalAZero(final int valeur) {
if(valeur == 0) {
System.out.println(“L’entier passé en paramètre vaut 0”);
} else {
System.out.println(“L’entier passé en paramètre est différent de 0”);
}
}À l'exécution, l'expression `valeur == 0` sera évaluée et renverra true (si valeur vaut 0) ou false dans tous les autres cas.
Voyons un autre exemple :
public static void meteo(final boolean beauTemps) {
if(beauTemps) {
System.out.println(“Je vais à la plage”);
} else {
System.out.println(“Je vais au cinéma”);
}
}Étant donné que la variable beauTemps est déjà un booléen, Java évaluera directement son contenu et il n'est pas nécessaire d'y appliquer un opérateur de comparaison.
Continuons avec un exemple qui permet de vérifier la négation :
public static void meteo(final boolean beauTemps) {
if(!beauTemps) {
System.out.println(“Le temps n'est pas beau.”);
}
}L’utilisation du !devant une expression booléenne permet donc de vérifier la négation.
Si vous souhaitez comparer deux chaînes de caractères, vous devrez utiliser une fonction nommée equals. L’opérateur == n’est pas adapté à cette situation. Par exemple :
public static void meteo(final String temps) {
if(temps.equals(“soleil”) {
System.out.println(“Je vais à la plage”);
}
}La fonction equals renvoie vrai ou faux selon l’égalité obtenue.
Enfin, nous pouvons aussi combiner des conditions grâce aux opérateurs logiques :
ET dont le symbole est &&
OU dont le symbole est ||
Imaginons qu’on veuille vérifier si une valeur est entre 0 et 10 exclus : if(valeur > 0 && valeur < 10)
Maintenant si l’on souhaite vérifier qu’une valeur vaut 10 ou 20 : if(valeur == 10 || valeur == 20)
Tu nous as montré comment traiter un scénario et son opposé, mais comment gérer plusieurs possibilités ?
Très bon point ! Si demain il fait beau, je vais à la plage, mais s’il fait nuageux je vais juste me promener, sinon je reste à la maison.
Tout d’abord sachez qu’on peut combiner des instructions if de la façon suivante :
if( première condition ) {
} else if ( deuxième condition ) {
} else {
}Que se passerait-il si on avait de nombreuses conditions à vérifier ?
C’est une bonne question, on pourrait enchaîner les `else if` mais je préfère vous montrer quelque chose de plus intéressant.
Vérifiez plusieurs cas possibles
Laissez-moi à présent vous montrer la structure itérative switch :
Que pouvez-vous retenir ?
Le mot-clé case permet de définir une possibilité tandis que -> précède l’instruction à exécuter.
Si l’expression ne correspond à aucun case, c’est l’instruction associée à default qui sera exécutée
Voici le code vu ensemble :
public static void commenteLaMeteo(final String meteo) {
switch (meteo) {
case “soleil” -> System.out.println("Beau temps");
case “nuage“ -> System.out.println("Couvert");
case “pluie“ -> System.out.println("Mauvais temps");
default -> System.out.println(“Je ne sais pas.”);
}
}Allez, faisons un autre exemple !
Que pouvez-vous retenir cette fois-ci ?
Le résultat du switch peut directement être affecté à une variable.
Les possibilités peuvent être chaînées dans un case.
Si les instructions sont dans un bloc { } le mot-clé yield doit être utilisé.
Et voici également le code :
public static String categorieDeFilm(final String film) {
var resultat = switch (film) {
case “Star Wars” -> “Science fiction”;
case “Blanche neige”, “La petite sirène” -> “Disney”;
case “Indiana Jones” -> {
String categorie = “Aventure”;
yield categorie;
}
default -> “Inconnu”;
};
return resultat;
}Nous sommes allés au bout des structures conditionnelles, passons maintenant aux structures itératives !
Itérez avec while
Alors, c’est quoi une structure itérative ?
C’est un code que l’on peut répéter. Il existe 2 grandes catégories de structures itératives :
Tant que
Pour
Commençons par examiner la catégorie de boucle Tant que. L’idée est de répéter un bloc d’instructions tant qu’une condition est vérifiée. Le mot-clé Java est while. Notez ce code :
public static void affiche() {
int chiffre = 0;
while(chiffre < 5) {
System.out.println(chiffre);
chiffre++;
}
}Ce code très basique signifie que tant que la variable chiffre est inférieure à 5 alors on affiche le chiffre puis on incrémente de 1. En effet, l’ajout des opérateurs `++` à la suite d’une variable numérique va ajouter 1 à la valeur de la variable.
Quels chiffres s’afficheront dans la console ?
La réponse est : 0, 1, 2, 3, 4. Et cela car il y a eu 5 itérations, les instructions de la boucle ont été exécutées 5 fois.
Maintenant imaginez que la variable chiffre ait été initialisée à 5, que se serait-il passé ?
Rien ! Le code de la boucle n’aurait jamais été exécuté. Parfois on aimerait s’assurer que le code soit exécuté au moins une fois indépendamment du résultat de l’évaluation de la condition. Voilà comment faire :
public static void affiche() {
int chiffre = 0;
do {
System.out.println(chiffre);
chiffre++;
} while(chiffre == 1);
}La boucle utilisée est une do { } while( ); Les instructions définies dans le do seront d’abord exécutées puis si la condition du while est vraie, elles seront de nouveau exécutées et ainsi de suite. Nous sommes donc assurés de voir le bloc d’instruction s’exécuter au moins une fois !
Passons à la deuxième catégorie de structures itératives, les boucles for.
Itérez avec for
Je vais commencer par la boucle Pour suivante :
public static void compteJusquaDix() {
for(int i=1; i<=10; i++) {
System.out.println(i);
}
}Tout d’abord le mot-clé Java est for. Vis-à-vis d’une boucle while, la syntaxe est un peu plus complexe, décomposons le contenu des parenthèses :
int i=1;: on déclare et initialise une variable de type int nommée i avec la valeur 1.i<=10;: on définit une condition de fin de boucle, si la variable i est inférieure ou égale à 10.i++;: on incrémente la variable i de 1 à chaque itération.
La boucle va donc évaluer le contenu de la variable i. S’il est inférieur ou égal à 10, les instructions seront exécutées puis la variable i sera incrémentée. De nouveau son contenu est évalué et s’il est toujours inférieur ou égal à 10 les instructions seront de nouveau exécutées et ainsi de suite…
C’est pas mal mais il faut reconnaître que la notation n’est pas très belle. Découvrons un autre type de for dans la démonstration suivante :
En résumé :
List est un type complexe permettant de gérer un ensemble d'éléments. On peut dire que c’est un tableau évolué. On lui spécifie quel type d’élément il va gérer grâce à la notation List<Type>.
Le code
Arrays.asList("Java", "PHP", "JavaScript");permet de créer une liste de 3 éléments de type String à savoir Java, PHP et JavaScript.La boucle :
for(String nomDUnLangage : nomsDesLangages)permet de parcourir la liste. À la première itération, le premier élément de la liste sera affecté à la variable nomDUnLangage puis les instructions seront exécutées. Ensuite, ce sera le tour du second élément et enfin du troisième.
Voici le code vu ensemble :
public static void main(String[] args) {
List<String> nomsDesLangages = Arrays.asList("Java", "PHP", "JavaScript");
for (String nomDUnLangage : nomsDesLangages) {
System.out.println(nomDUnLangage);
}
}Nous venons de finir de traiter les cas principaux de structures itératives !
À vous de jouer
Contexte
Vous retrouvez Marc à la machine à café.
J’ai passé une tête au-dessus de ton épaule et j’ai noté que tu bosses dur, c’est bien. Appréhender les conditions et les boucles est fondamental !
Il faut cependant reconnaître que vous manquez de pratique. Hema, une développeuse expérimentée de l’entreprise assiste à cet échange et intervient :
Je me souviens de mes premiers pas en Java, ce n’était pas si simple ! Si tu veux, je t’envoie un exercice qui permet de t’entraîner.
Vous repartez à votre bureau, ravi de la solidarité des collègues, et recevez dans les minutes qui suivent un email d’Hema avec la consigne suivante :
Consignes
Dans la fonction principale main, déclarez un tableau d’entier à 7 cases contenant les valeurs de votre choix.
Bouclez sur chaque case.
Si la valeur est égale à 0, incrémentez une variable nommée cpt.
Après l’exécution de la boucle, afficher la variable cpt.
En résumé
Une structure conditionnelle permet d’exécuter des instructions en fonction de l’évaluation d’une condition.
En Java, les mots-clés sont if { } else { }.
Pour évaluer plusieurs conditions, la structure conditionnelle switch peut être utilisée.
Pour itérer utilisez une boucle while() { } , do { } while(); ou for() { }.
Je tiens sincèrement à vous féliciter pour avoir suivi la première partie de ce cours. Vous voilà armé pour vous attaquer au paradigme objet. On se retrouve au prochain chapitre ! Mais avant cela, testez vos connaissances dans le quiz clôturant ce chapitre.
