Structures de Contrôle et Boucles en Java

1. Les branchements conditionnels

Les branchements conditionnels permettent d'exécuter différents blocs de code en fonction de l'évaluation d'une expression booléenne (true ou false).

1.1. Les instructions if, else if et else

La structure if-else est la forme la plus fondamentale de branchement. Vous la connaissez déjà bien. En Java, sa syntaxe est très proche de celle du C ou du JavaScript.

La vidéo suivante est une excellente introduction pratique à l'implémentation des conditions en Java.

Voici un résumé du code typique que vous écrirez :

int age = 25;

if (age < 18) {
    System.out.println("Vous êtes mineur.");
} else if (age >= 18 && age < 65) {
    System.out.println("Vous êtes un adulte actif.");
} else {
    System.out.println("Vous êtes à la retraite.");
}

On peut également imbriquer les conditions pour des logiques plus fines.

1.2. L'opérateur ternaire

Pour des affectations conditionnelles simples, Java propose un raccourci : l'opérateur ternaire ? :. Il est très pratique pour rendre le code plus concis.

Sa syntaxe est : variable = (condition) ? valeur_si_vrai : valeur_si_faux;

// Version avec if-else
String statut;
if (age >= 18) {
    statut = "Majeur";
} else {
    statut = "Mineur";
}

// Version équivalente avec l'opérateur ternaire
String statutTernaire = (age >= 18) ? "Majeur" : "Mineur";

System.out.println(statutTernaire); // Affiche "Majeur"

1.3. L'instruction switch

Lorsque vous devez tester une seule variable par rapport à une liste de valeurs discrètes (nombres, caractères, chaînes de caractères), une longue suite de if-else if peut devenir lourde. L'instruction switch est une alternative plus propre et souvent plus performante.

Les points clés du switch "classique" sont :

• Chaque case se termine par un break pour empêcher l'exécution de continuer dans les cas suivants (ce qu'on appelle le "fall-through").
• Le default est optionnel et s'exécute si aucune valeur de case ne correspond.

int jourDeLaSemaine = 3; // 1 pour Lundi, 2 pour Mardi, etc.
String nomJour;

switch (jourDeLaSemaine) {
    case 1:
        nomJour = "Lundi";
        break;
    case 2:
        nomJour = "Mardi";
        break;
    case 3:
        nomJour = "Mercredi";
        break;
    // ... autres jours
    default:
        nomJour = "Jour invalide";
        break;
}
System.out.println(nomJour); // Affiche "Mercredi"

1.4. Le switch moderne (depuis Java 14)

En tant que futur développeur professionnel, il est important de connaître les évolutions récentes du langage. Depuis Java 14, switch peut être utilisé comme une expression qui retourne une valeur, avec une syntaxe plus concise utilisant une flèche ->.

Cette nouvelle syntaxe a deux avantages majeurs :

1. Plus besoin de break. Le code associé à un case est isolé.
2. Le switch entier peut être directement assigné à une variable, ce qui rend le code beaucoup plus lisible.

// Version moderne du code précédent
String nomJourModerne = switch (jourDeLaSemaine) {
    case 1 -> "Lundi";
    case 2 -> "Mardi";
    case 3 -> "Mercredi";
    // ...
    default -> "Jour invalide";
}; // Notez le point-virgule à la fin car c'est une expression
System.out.println(nomJourModerne);

Cette forme est aujourd'hui considérée comme une meilleure pratique. Le document ci-dessous, très complet, détaille ces évolutions. Vous n'avez pas besoin de tout lire, mais il constitue une excellente référence.

2. Les boucles (itérations)

Les boucles sont utilisées pour répéter un bloc de code plusieurs fois.

La vidéo suivante vous guidera à travers les principales boucles en Java.

2.1. La boucle while

La boucle while répète un bloc de code tant que sa condition est vraie. La condition est vérifiée avant chaque itération.

int compteur = 0;
while (compteur < 5) {
    System.out.println("Le compteur est à : " + compteur);
    compteur++; // Attention à ne pas oublier d'incrémenter !
}

2.2. La boucle do-while

Similaire à while, mais la condition est vérifiée après chaque itération. Cela garantit que le bloc de code est exécuté au moins une fois.

int choixUtilisateur;
// import java.util.Scanner; // à mettre en haut du fichier
// Scanner scanner = new Scanner(System.in);

do {
    System.out.println("Faites un choix (tapez 0 pour sortir)");
    // choixUtilisateur = scanner.nextInt(); 
    choixUtilisateur = 0; // Pour l'exemple sans Scanner
} while (choixUtilisateur != 0);

System.out.println("Sortie du programme.");

2.3. La boucle for classique

C'est la boucle la plus courante lorsque le nombre d'itérations est connu à l'avance. Sa structure compacte regroupe l'initialisation, la condition et l'incrémentation.

// Affiche les nombres de 0 à 9
for (int i = 0; i < 10; i++) {
    System.out.print(i + " ");
}
System.out.println();

// Décompte de 5 à 1
for (int i = 5; i > 0; i--) {
    System.out.print(i + " ");
}

2.4. La boucle for-each (améliorée)

Lorsque vous voulez simplement parcourir tous les éléments d'un tableau ou d'une collection, sans vous soucier des index, la boucle for-each est la plus simple et la plus sûre.

Dans la leçon précédente, nous avons vu que String.split() retournait un String[] (un tableau de chaînes). C'est le moment idéal pour utiliser for-each !

String data = "nom:Dupont;ville:Paris;pays:France";
String[] pairs = data.split(";"); // ["nom:Dupont", "ville:Paris", "pays:France"]

System.out.println("Parcourons les paires clé-valeur :");
for (String pair : pairs) {
    System.out.println("- " + pair);
}

C'est beaucoup plus clair et moins sujet aux erreurs que d'utiliser une boucle for classique avec un index.

2.5. Quand choisir quelle boucle ?

La vidéo donne de bons conseils à ce sujet. Voici un résumé :

• for : Utilisez-la quand vous connaissez le nombre d'itérations (ex: "répéter 10 fois", "parcourir les indices de 0 à N-1").
• for-each : Le meilleur choix pour parcourir tous les éléments d'un tableau ou d'une collection.
• while : Utilisez-la quand le nombre d'itérations est inconnu et dépend d'une condition qui peut changer (ex: "lire un fichier jusqu'à la fin", "attendre une entrée utilisateur").
• do-while : Comme while, mais quand vous avez besoin que le code s'exécute au moins une fois.

3. Contrôler le flux des boucles : break et continue

Parfois, vous devez altérer le comportement normal d'une boucle.

• break : Permet de sortir immédiatement et complètement de la boucle.
• continue : Permet de sauter le reste de l'itération en cours et de passer directement à l'itération suivante.

Exemple : trouver le premier nombre divisible par 7 dans une plage.

for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0) {
        System.out.println("Le premier nombre divisible par 7 est : " + i);
        break; // Sort de la boucle dès qu'on l'a trouvé
    }
}

Exemple : afficher uniquement les nombres impairs.

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // Si i est pair, on saute le println et on passe à l'itération suivante
    }
    System.out.print(i + " "); // N'affiche que 1 3 5 7 9
}

4. Exercice pratique

Mettons tout cela en pratique. L'exercice suivant vous demande de modéliser une boîte de vitesses, ce qui vous obligera à utiliser des conditions pour gérer les changements d'état.

Astuce : Dans la méthode changerVitesse(), vous devrez vérifier que la vitesse actuelle est inférieure à 5 avant de l'incrémenter. La logique est similaire pour retrograder(). Pour toString(), un switch moderne (expression) serait particulièrement élégant !

Conclusion

Félicitations ! Vous maîtrisez maintenant les outils fondamentaux pour diriger le flux de n'importe quel programme Java.

Points clés à retenir :

• Utilisez if-else if-else pour des branchements conditionnels complexes.
• Préférez switch (idéalement dans sa forme moderne avec ->) pour tester une variable contre des valeurs discrètes.
• La boucle for-each est le moyen le plus sûr et lisible de parcourir tous les éléments d'un tableau ou d'une collection.
• La boucle for classique est utile pour un contrôle fin sur les indices, et while pour des conditions d'arrêt dynamiques.
• break quitte une boucle, continue saute à l'itération suivante.

Dans la prochaine leçon, nous rendrons nos applications interactives. Nous apprendrons à lire une entrée utilisateur depuis la console avec la classe Scanner, ce qui nous permettra de tester notre code avec des données dynamiques sans avoir à le recompiler à chaque fois.