Introduction aux structures de contrôle

En Java, le flux d'exécution d'un programme est dirigé par des structures de contrôle. Elles se divisent en trois catégories principales : la structure séquentielle (exécution linéaire de haut en bas), les structures conditionnelles (if, switch) et les structures de répétition (for, while, do-while).

Les structures conditionnelles

L'instruction if

La structure if permet d'exécuter un bloc de code uniquement si une condition booléenne est évaluée à true.

Format de base :

if (expression_booléenne) {
    // instructions
}

Règles importantes :

• Il est fortement recommandé de toujours utiliser des accolades, même pour une seule instruction, afin d'éviter les erreurs logiques.
• Ajouter un point-virgule directement après la condition crée un bloc vide, ce qui est souvent une erreur involontaire.
• L'expression entre parenthèses doit impérativement être de type booléen.

public class TemperatureCheck {
    public static void main(String[] args) {
        int temperature = -5;
        
        if (temperature < 0) {
            System.out.println("Attention : risque de verglas.");
        }
        
        System.out.println("Fin de la vérification.");
    }
}

La structure if-else

Utilisée pour exécuter un bloc parmi deux possibles (exclusivité).

public class AgeVerification {
    public static void main(String[] args) {
        int userAge = 17;
        
        if (userAge >= 18) {
            System.out.println("Accès autorisé.");
        } else {
            System.out.println("Accès refusé : mineur.");
        }
    }
}

La structure if-else if-else

Permet d'évaluer plusieurs conditions séquentielles. Dès qu'une condition est vraie, son bloc est exécuté et le reste est ignoré.

import java.util.Scanner;

public class WindSpeedAlert {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Entrez la vitesse du vent (km/h) : ");
        int windSpeed = scanner.nextInt();

        if (windSpeed >= 0 && windSpeed < 30) {
            System.out.println("Brise légère.");
        } else if (windSpeed >= 30 && windSpeed < 60) {
            System.out.println("Vent fort.");
        } else if (windSpeed >= 60 && windSpeed < 90) {
            System.out.println("Tempête.");
        } else if (windSpeed >= 90) {
            System.out.println("Ouragan.");
        } else {
            System.out.println("Vitesse invalide.");
        }
    }
}

L'instruction switch

Le switch est idéal pour tester l'égalité d'une variable contre plusieurs valeurs constantes.

Contraintes et bonnes pratiques :

• L'expression doit être de type byte, short, int, char, String (depuis Java 7) ou une énumération.
• Les étiquettes case doivent être des constantes.
• Le mot-clé break est crucial pour éviter le "fall-through" (cascade) vers les cas suivants.
• Le bloc default est optionnel mais recommandé pour la robustesse. Il peut être placé n'importe où dans le switch.

import java.util.Scanner;

public class RestaurantMenu {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Choisissez votre plat (1-3) : ");
        int choice = scanner.nextInt();

        switch (choice) {
            case 1:
                System.out.println("Vous avez commandé une Pizza.");
                break;
            case 2:
                System.out.println("Vous avez commandé un Burger.");
                break;
            case 3:
                System.out.println("Vous avez commandé une Salade.");
                break;
            default:
                System.out.println("Choix non valide.");
                break;
        }
    }
}

Le switch est également très efficace pour regrouper plusieurs cas ayant la même action :

import java.util.Scanner;

public class HttpStatusChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Entrez un code HTTP : ");
        String code = scanner.next();

        switch (code) {
            case "200":
                System.out.println("OK - Succès");
                break;
            case "404":
                System.out.println("Not Found - Non trouvé");
                break;
            case "500":
                System.out.println("Internal Server Error - Erreur serveur");
                break;
            default:
                System.out.println("Code non reconnu.");
                break;
        }
    }
}

Les structures de répétision

La boucle for

La boucle for est utilisée lorsque le nombre d'itérations est connu à l'avance.

Format : for (initialisation; condition; incrémentation) { ... }

Notes :

• L'initialisation n'est exécutée qu'une seule fois au début.
• Omettre la condition crée une boucle infinie (ex: for(;;)).

public class SquarePrinter {
    public static void main(String[] args) {
        for (int counter = 1; counter <= 5; counter++) {
            int square = counter * counter;
            System.out.println("Le carré de " + counter + " est " + square);
        }
    }
}

Exemple de calculs mathématiques combinés :

public class MathCalculations {
    public static void main(String[] args) {
        int multiplesSum = 0;
        for (int num = 1; num <= 20; num++) {
            if (num % 3 == 0) {
                multiplesSum += num;
            }
        }
        System.out.println("Somme des multiples de 3 (1-20) : " + multiplesSum);

        int factorial = 1;
        for (int i = 1; i <= 6; i++) {
            factorial *= i;
        }
        System.out.println("Factorielle de 6 : " + factorial);
    }
}

Recherche de nombres d'Armstrong (nombres de Narcisse) à trois chiffres :

public class ArmstrongNumbers {
    public static void main(String[] args) {
        int totalFound = 0;
        for (int candidate = 100; candidate <= 999; candidate++) {
            int hundreds = candidate / 100;
            int tens = (candidate / 10) % 10;
            int units = candidate % 10;

            int sumOfCubes = (hundreds * hundreds * hundreds) +
                             (tens * tens * tens) +
                             (units * units * units);

            if (sumOfCubes == candidate) {
                System.out.println("Nombre trouvé : " + candidate);
                totalFound++;
            }
        }
        System.out.println("Total : " + totalFound);
    }
}

Génération de motifs géométriques avec des boucles imbriquées :

public class PatternGenerator {
    public static void main(String[] args) {
        // Triangle rectangle inversé
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++) {
                System.out.print("# ");
            }
            System.out.println();
        }

        System.out.println("---");

        // Grille 4x4
        for (int r = 0; r < 4; r++) {
            for (int c = 0; c < 4; c++) {
                System.out.print("O ");
            }
            System.out.println();
        }
    }
}

La boucle while

La boucle while évalue la condition avant d'exécuter le bloc. Elle est préférée lorsque le nombre d'itérations n'est pas connu à l'avance.

public class InvestmentGrowth {
    public static void main(String[] args) {
        double principal = 1000.0;
        double target = principal * 2;
        double rate = 0.05; // 5% d'intérêt annuel
        int years = 0;

        while (principal < target) {
            principal += principal * rate;
            years++;
        }
        System.out.println("Il faut " + years + " années pour doubler le capital.");
    }
}

La boucle do-while

Contrairement au while, la boucle do-while évalue la condition après l'exécution du bloc. Cela garantit que le code s'exécute au moins une fois.

import java.util.Scanner;

public class SystemMenu {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int option;

        do {
            System.out.println("--- MENU ---");
            System.out.println("1. Démarrer");
            System.out.println("2. Arrêter");
            System.out.println("0. Quitter");
            System.out.print("Votre choix : ");
            option = scanner.nextInt();

            if (option == 1) {
                System.out.println("Système démarré.");
            } else if (option == 2) {
                System.out.println("Système arrêté.");
            }
        } while (option != 0);

        System.out.println("Fin du programme.");
    }
}