Tutoriel sur le flux de contrôle Java : Instructions conditionnelles et boucles | Laboratoire pratique

Introduction

Dans ce laboratoire, vous plongerez dans le monde des structures de contrôle de flux en Java. Ce sont des outils essentiels qui permettent à vos programmes de prendre des décisions et de répéter des actions. Nous aborderons trois concepts principaux :

Les instructions if-else pour la prise de décision
Les boucles for pour répéter des actions un nombre connu de fois
Les boucles while pour répéter des actions lorsque vous ne savez pas combien de fois vous devrez les répéter

Ne vous inquiétez pas si ces termes vous semblent inconnus - nous expliquerons chacun d'eux en détail. À la fin de ce laboratoire, vous serez capable d'écrire des programmes Java capables de prendre des décisions et de répéter des actions, ouvrant ainsi un tout nouveau monde de possibilités dans votre parcours de programmation!

Comprendre les instructions if-else

Imaginez que vous créez un programme qui donne des conseils météorologiques. Vous voulez qu'il suggère différentes choses en fonction de la température. C'est là que les instructions if-else sont utiles!

Ouvrez le fichier WeatherAdvisor.java dans le WebIDE. Vous verrez ce code :
```
public class WeatherAdvisor {
    public static void main(String[] args) {
        int temperature = 28; // Temperature in Celsius

        System.out.println("The temperature is " + temperature + "°C.");

        // TODO: Add if-else statements here to provide weather advice
    }
}
```
Voici une explication du code :
1. public class WeatherAdvisor :
  - Cette ligne déclare une classe publique nommée WeatherAdvisor.
  - En Java, chaque programme doit avoir au moins une classe, et le nom de la classe doit correspondre au nom du fichier (dans ce cas, WeatherAdvisor.java).
2. public static void main(String[] args) :
  - C'est la méthode principale, qui est le point d'entrée de tout programme Java.
  - public : Cette méthode peut être accédée depuis l'extérieur de la classe.
  - static : Cette méthode appartient à la classe elle - même, pas à une instance spécifique de la classe.
  - void : Cette méthode ne renvoie aucune valeur.
  - main : C'est le nom de la méthode. Java cherche une méthode nommée "main" pour commencer l'exécution du programme.
  - (String[] args) : Cela permet à la méthode d'accepter des arguments de ligne de commande (bien que nous ne les utilisions pas dans cet exemple).
3. int temperature = 28; :
  - Cette ligne déclare une variable entière nommée temperature et l'initialise avec la valeur 28.
  - int est le type de données pour les nombres entiers en Java.
  - Le commentaire // Temperature in Celsius explique ce que représente cette valeur.
4. System.out.println("The temperature is " + temperature + "°C."); :
  - Cette ligne affiche un message dans la console.
  - System.out.println() est une méthode qui affiche du texte et passe à la ligne suivante.
  - L'opérateur + est utilisé ici pour la concaténation de chaînes de caractères, combinant le texte avec la valeur de la variable temperature.
  - Le °C à la fin ajoute le symbole Celsius à la sortie.
Cette structure de base configure un programme qui définit une température et l'affiche. Elle fournit une base pour ajouter une logique plus complexe, comme les instructions if-else que nous avons ajoutées plus tard pour donner des conseils météorologiques en fonction de la valeur de la température.

Remplacez le commentaire TODO par le code suivant :

if (temperature > 30) {
    System.out.println("It's a hot day. Remember to stay hydrated!");
} else if (temperature > 20) {
    System.out.println("It's a nice warm day. Enjoy the weather!");
} else if (temperature > 10) {
    System.out.println("It's a bit cool. You might need a light jacket.");
} else {
    System.out.println("It's cold. Wear warm clothes!");
}

Exemple de code if-else

Analysons cela :

L'instruction if vérifie si la température est supérieure à 30°C.
Si ce n'est pas le cas, elle passe au premier else if et vérifie si elle est supérieure à 20°C.
Cela continue jusqu'à ce qu'elle trouve une condition qui est vraie, ou qu'elle atteigne le else à la fin.
Seulement l'un de ces blocs sera exécuté - dès qu'une condition est vraie, Java saute tous les autres.

Enregistrez le fichier. Dans la plupart des IDE, y compris le WebIDE, vous pouvez enregistrer en appuyant sur Ctrl+S (ou Cmd+S sur Mac).
Maintenant, compilons le programme. Dans le terminal en bas de votre WebIDE, tapez :
```
javac ~/project/WeatherAdvisor.java
```
Cette commande demande à Java de compiler votre code. Si vous ne voyez aucune sortie, c'est bon! Cela signifie qu'il n'y a eu aucune erreur.
Pour exécuter le programme, tapez :
```
java -cp ~/project WeatherAdvisor
```
La partie -cp ~/project indique à Java où trouver votre code compilé.
Vous devriez voir cette sortie :
```
The temperature is 28°C.
It's a nice warm day. Enjoy the weather!
```
Cela correspond à notre code car 28°C est supérieur à 20°C mais pas supérieur à 30°C.
Expérimentons! Changez la valeur de temperature dans le code en 35, puis enregistrez, compilez et exécutez à nouveau. Vous devriez voir :
```
The temperature is 35°C.
It's a hot day. Remember to stay hydrated!
```
Essayez de changer la température à 15 et 5, en compilant et en exécutant chaque fois. Observez comment la sortie change!

Félicitations! Vous venez d'écrire un programme qui prend des décisions. C'est un concept fondamental en programmation que vous utiliserez tout le temps.

Utilisation des boucles for

Maintenant, apprenons à utiliser les boucles for. Elles sont idéales lorsque vous voulez répéter une action un nombre spécifique de fois, comme créer une table de multiplication!

Ouvrez le fichier MultiplicationTable.java dans le WebIDE. Vous verrez :

public class MultiplicationTable {
    public static void main(String[] args) {
        int number = 5;
        System.out.println("Multiplication table for " + number + ":");

        // TODO: Add a for loop here to print the multiplication table
    }
}

Remplacez le commentaire TODO par cette boucle for :
```
for (int i = 1; i <= 10; i++) {
    int result = number * i;
    System.out.println(number + " x " + i + " = " + result);
}
```
Analysons cela :
- for (int i = 1; i <= 10; i++) est l'instruction de boucle for :
  - int i = 1 crée une variable i et l'initialise à 1. Cela se produit une seule fois au début.
  - i <= 10 est la condition. La boucle continue tant que cette condition est vraie.
  - i++ incrémente i de 1 à chaque fin de boucle.
- À l'intérieur de la boucle, nous multiplions number par i et affichons le résultat.
- Cela se répétera 10 fois, avec i allant de 1 à 10.
Enregistrez le fichier.

Compilez le programme :

javac ~/project/MultiplicationTable.java

Exécutez le programme :
```
java -cp ~/project MultiplicationTable
```

Vous devriez voir la table de multiplication de 5 :

Multiplication table for 5:
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

Voyez comment elle a affiché la table de 1 à 10? C'est notre boucle for en action!

Expérimentons! Changez la variable number en 7, puis enregistrez, compilez et exécutez à nouveau. Vous devriez voir la table de multiplication de 7.
Vous voulez en voir plus? Essayez de changer i <= 10 en i <= 15 dans la boucle for. Cela fera que la table ira jusqu'à 15 au lieu de 10.

Les boucles for sont incroyablement utiles lorsque vous savez exactement combien de fois vous voulez répéter une action. Vous les utiliserez souvent dans votre parcours de programmation!

Exploration des boucles while

Les boucles while sont parfaites pour les situations où vous ne savez pas à l'avance combien de fois vous devez répéter une action. Utilisons-en une pour créer un jeu de devinette de nombre!

Ouvrez le fichier GuessTheNumber.java dans le WebIDE. Vous verrez :

import java.util.Random;
import java.util.Scanner;

public class GuessTheNumber {
    public static void main(String[] args) {
        Random random = new Random();
        int numberToGuess = random.nextInt(100) + 1; // Random number between 1 and 100
        Scanner scanner = new Scanner(System.in);
        int guess;
        int attempts = 0;

        System.out.println("I'm thinking of a number between 1 and 100. Can you guess it?");

        // TODO: Add a while loop here to implement the guessing game

        scanner.close();
    }
}

Ce code configure un nombre aléatoire que le joueur doit deviner, et un scanner pour lire l'entrée du joueur.

Remplacez le commentaire TODO par cette boucle while :
```
while (true) {
    System.out.print("Enter your guess: ");
    guess = scanner.nextInt();
    attempts++;

    if (guess < numberToGuess) {
        System.out.println("Too low! Try again.");
    } else if (guess > numberToGuess) {
        System.out.println("Too high! Try again.");
    } else {
        System.out.println("Congratulations! You guessed the number in " + attempts + " attempts.");
        break;
    }
}
```
Analysons cela :
- while (true) crée une boucle infinie. Elle continuera jusqu'à ce que nous lui disions d'arrêter.
- À l'intérieur de la boucle, nous demandons un nombre à deviner et nous augmentons le compteur d'essais.
- Nous utilisons des instructions if-else pour vérifier si le nombre deviné est trop bas, trop haut ou correct.
- Si le nombre deviné est correct, nous affichons un message de félicitations et utilisons break pour sortir de la boucle.
Enregistrez le fichier.
Compilez le programme :
```
javac ~/project/GuessTheNumber.java
```
Exécutez le programme :
```
java -cp ~/project GuessTheNumber
```

Sortie du programme GuessTheNumber

Maintenant, jouez au jeu! Continuez à entrer des nombres jusqu'à ce que vous deviniez correctement. Le programme vous indiquera si votre nombre est trop haut ou trop bas.

Cette boucle while continue jusqu'à ce que le nombre correct soit deviné. Nous ne savons pas combien d'essais cela prendra, c'est pourquoi une boucle while est parfaite ici.

Combinaison des structures de contrôle

Pour notre dernier défi, nous allons combiner des instructions if-else, des boucles for et des boucles while pour créer un programme de recherche de nombres premiers!

Ouvrez le fichier PrimeNumberFinder.java dans le WebIDE. Vous verrez :

import java.util.Scanner;

public class PrimeNumberFinder {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = 0;
        int number = 2;

        System.out.print("How many prime numbers do you want to find? ");
        int maxPrimes = scanner.nextInt();

        System.out.println("First " + maxPrimes + " prime numbers:");

        // TODO: Implement the prime number finding logic here

        scanner.close();
    }
}

Remplacez le commentaire TODO par ce code :
```
while (count < maxPrimes) {
    boolean isPrime = true;

    for (int i = 2; i <= Math.sqrt(number); i++) {
        if (number % i == 0) {
            isPrime = false;
            break;
        }
    }

    if (isPrime) {
        System.out.print(number + " ");
        count++;
    }

    number++;
}
```
Cela semble complexe, mais analysons-le :
- Nous utilisons une boucle while pour continuer à rechercher des nombres premiers jusqu'à ce que nous ayons le nombre souhaité.
- Pour chaque nombre, nous utilisons une boucle for pour vérifier s'il est premier.
- Nous utilisons Math.sqrt(number) comme optimisation - nous n'avons besoin de vérifier que jusqu'à la racine carrée du nombre.
- Si nous trouvons un diviseur, nous savons que le nombre n'est pas premier, donc nous définissons isPrime sur false et nous sortons de la boucle interne.
- Si isPrime est toujours true après la boucle for, nous affichons le nombre et nous augmentons notre compteur.
- Nous augmentons toujours number à la fin pour passer au nombre suivant.
Enregistrez le fichier.
Compilez le programme :
```
javac ~/project/PrimeNumberFinder.java
```
Exécutez le programme :
```
java -cp ~/project PrimeNumberFinder
```
Lorsque vous y êtes invité, entrez un nombre (comme 10) pour trouver ce nombre de nombres premiers. Vous devriez voir une sortie comme celle-ci :
```
How many prime numbers do you want to find? 10
First 10 prime numbers:
2 3 5 7 11 13 17 19 23 29
```

Ce programme montre à quel point Java peut être puissant lorsque vous combinez différentes structures de contrôle. Vous êtes maintenant capable de créer des programmes qui peuvent prendre des décisions, répéter des actions et résoudre des problèmes complexes!

Résumé

Travail fantastique! Dans ce laboratoire, vous avez maîtrisé certains des concepts les plus importants de la programmation Java :

Instructions if-else : Vous les avez utilisées pour prendre des décisions dans votre programme de conseil météorologique.
Boucles for : Vous les avez utilisées pour créer une table de multiplication, en répétant une action un nombre spécifique de fois.
Boucles while : Vous les avez utilisées dans votre jeu de devinette, en répétant une action jusqu'à ce qu'une condition soit remplie.
Combinaison de structures de contrôle : Vous avez tout combiné pour créer un programme de recherche de nombres premiers.

Ces structures de flux de contrôle sont les éléments de base des programmes complexes. Avec elles, vous pouvez créer des programmes qui prennent des décisions, répètent des actions et résolvent des problèmes complexes.

N'oubliez pas que la pratique fait parfait. Essayez de modifier ces programmes ou de créer de nouveaux en utilisant ces concepts. Pouvez-vous créer un programme qui donne des conseils différents pour chaque jour de la semaine? Ou un programme qui affiche une table de multiplication pour n'importe quel nombre jusqu'à 100? Les possibilités sont infinies!

Continuez à coder, continuez à apprendre et, surtout, amusez-vous! Vous êtes bien en route pour devenir un expert Java.