Les instructions de contrôle de flux en Java

Chapitre 4 : Instructions de contrôle de flux

1. Présentation

1.1 Explication

L'ordre d'exécution des instructions dans un programme a un impact direct sur le résultat. Le flux d'exécution détermine le comportement du programme. Il est donc essentiel de comprendre le流程 d'exécution de chaque instruction. Souvent, nous devons contrôler l'ordre d'exécution pour implémenter les fonctionnalités souhaitées.

En résumé : Les instructions de contrôle de flux permettent de gérer l'ordre d'exécution des instructions dans un programme, en les regroupant en modules logiques accomplishant des tâches spécifiques.

1.2 Catégories

  • Structure séquentielle
  • Structure conditionnelle/sélection
    • if
    • switch
  • Structure itérative (boucles)
    • for
    • while
    • do...while

2. Structure séquentielle

2.1 Explication

La structure séquentielle est la plus simple : les instructions s'exécutent dans l'ordre où elles sont écrites, de haut en bas.

2.2 Exemple

public static void main(String[] args) {
    System.out.println(1);
    System.out.println(2);
    System.out.println(3);
}

3. Structure conditionnelle

3.1 Instruction if

3.1.1 Introduction

L'instruction if permet d'exécuter un traitement spécifique si une condition est satisfaite.

Par exemple : "Si tu obtiens 100和控制流 à ton examen, je t'emmènerai au parc d'attractions ce dimanche." Ce scénario peut être décrit en pseudo-code :

si (note == 100) {
    allerAuParcDAttractions()
}

3.1.2 Syntaxe

if (expressionConditionnelle) {
    instruction;
}

Flux d'exécution :

  1. Évaluer l'expression conditionnelle
  2. Si le résultat est true, exécuter les instructions
  3. Si le résultat est false, ne pas exécuter les instructions
  4. Poursuivre avec les instructions suivantes

3.1.3 Exemple

public static void main(String[] args) {
    System.out.println("Début");

    int valA = 10;
    int valB = 20;

    if (valA == valB) {
        System.out.println("valA equals valB");
    }

    int valC = 10;
    if (valA == valC) {
        System.out.println("valA equals valC");
    }

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

3.2 Instruction if...else

3.2.1 Explication

L'instruction if...else permet d'exécuter un traitement si une condition est vraie, sinon exécuter un autre traitement.

Exemple : Déterminer si un nombre entier positif est pair ou impair.

3.2.2 Syntaxe

if (expressionConditionnelle) {
    instruction1;
} else {
    instruction2;
}

3.2.3 Exemple

public static void main(String[] args) {
    int nombre = 19;
    if (nombre % 2 == 0) {
        System.out.println("Le nombre est pair");
    } else {
        System.out.println("Le nombre est impair");
    }
}

3.3 Instruction if...else if...else

3.3.1 Explication

L'instruction if...else if...else permet d'évaluer plusieurs conditions et d'effectuer différents traitements.

Exemple : Classer la note d'un étudiant (supérieur à 80 = excellent, supérieur à 70 = bien, supérieur à 60 = acceptable, sinon = insuffisant).

3.3.2 Syntaxe

if (expressionConditionnelle1) {
    instruction1;
} else if (expressionConditionnelle2) {
    instruction2;
} else if (expressionConditionnelleN) {
    instructionN;
} else {
    instructionParDefaut;
}

3.3.3 Exemple

public static void main(String[] args) {
    int score = 75;
    if (score > 80) {
        System.out.println("Excellent");
    } else if (score > 70) {
        System.out.println("Bien");
    } else if (score > 60) {
        System.out.println("Acceptable");
    } else {
        System.out.println("Insuffisant");
    }
}

3.3.4 Exemple 2

Objectif : Saisir un numéro de jour de la semaine (1-7) et afficher le jour correspondant.

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Entrez un numéro de jour (1-7) :");
    int jour = sc.nextInt();

    if (jour == 1) {
        System.out.println("Lundi");
    } else if (jour == 2) {
        System.out.println("Mardi");
    } else if (jour == 3) {
        System.out.println("Mercredi");
    } else if (jour == 4) {
        System.out.println("Jeudi");
    } else if (jour == 5) {
        System.out.println("Vendredi");
    } else if (jour == 6) {
        System.out.println("Samedi");
    } else {
        System.out.println("Dimanche");
    }
}

3.4 Conversion entre if et opérateur ternaire

3.4.1 Explication

L'opérateur ternaire et l'instruction if peuvent parfois être interchangeables.

3.4.2 Exemple

Objectif : Trouver le maximum entre deux nombres x et y :

public static void main(String[] args) {
    int x = 0;
    int y = 1;
    int max;
    if (x > y) {
        max = x;
    } else {
        max = y;
    }
}

Equivalent avec l'opérateur ternaire :

public static void main(String[] args) {
    int x = 0;
    int y = 1;
    int max = x > y ? x : y;
}

3.5 Instruction switch

3.5.1 Introduction

L'instruction switch évalue une expression et exécute le bloc de code correspondant à la valeur trouvée.

Exemple : Représenter les jours de la semaine par des chiffres de 1 à 7.

switch (chiffre) {
    case 1:
        afficher("Lundi");
        break;
    case 2:
        afficher("Mardi");
        break;
    // ...
}

3.5.2 Syntaxe

switch (expression) {
    case valeur1:
        instruction1;
        break;
    case valeur2:
        instruction2;
        break;
    default:
        instructionParDefaut;
        break;
}

Flux d'exécution :

  1. Évaluer l'expression
  2. Comparer avec chaque case
  3. En cas de correspondance, exécuter le bloc correspondant jusqu'au break
  4. Si aucune correspondance, exécuter le bloc default

3.5.3 Exemple 1

public static void main(String[] args) {
    int numeroJour = 6;

    switch (numeroJour) {
        case 1:
            System.out.println("Lundi");
            break;
        case 2:
            System.out.println("Mardi");
            break;
        case 3:
            System.out.println("Mercredi");
            break;
        case 4:
            System.out.println("Jeudi");
            break;
        case 5:
            System.out.println("Vendredi");
            break;
        case 6:
            System.out.println("Samedi");
            break;
        case 7:
            System.out.println("Dimanche");
            break;
        default:
            System.out.println("Numéro invalide");
            break;
    }
}

3.5.4 Perméation des cases

Si l'instruction break est absente, l'exécution continue au case suivant sans évaluer la condition.

public static void main(String[] args) {
    int valeur = 5;
    switch (valeur) {
        case 0:
            System.out.println("Exécution case 0");
            break;
        case 5:
            System.out.println("Exécution case 5");
        case 10:
            System.out.println("Exécution case 10");
        default:
            System.out.println("Exécution default");
    }
}

3.5.5 Exemple 2

La perméation peut simplifier l'écriture :

public static void main(String[] args) {
    int semaine = 2;
    switch (semaine) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            System.out.println("Jour ouvré");
            break;
        case 6:
        case 7:
            System.out.println("Week-end");
            break;
    }
}


public static void main(String[] args) {
    int mois = 6;
    switch (mois) {
        case 12:
        case 1:
        case 2:
            System.out.println("Hiver");
            break;
        case 3:
        case 4:
        case 5:
            System.out.println("Printemps");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("Été");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("Automne");
            break;
    }
}

3.5.6 Point Important

Le'xpression dans switch ne peut être que : byte, short, char, int, énumération (JDK5+), ou String (JDK7+).

Types non autorisés : long, float, double, boolean.

3.5.7 Nouvelles fonctionnalités switch (Java 12+)

switch(mois) {
    case 3,4,5 -> System.out.println("Printemps");
    case 6,7,8 -> System.out.println("Été");
    case 9,10,11 -> System.out.println("Automne");
    case 12,1,2 -> System.out.println("Hiver");
    default -> System.out.println("Mois invalide");
}

3.5.8 Comparaison entre if et switch

  • if : Condition booléenne, peut tester des plages de valeurs ou l'égalité
  • switch : Valeur constante (byte, short, int, char, énumération, String)
  • Pour tester l'égalité avec des valeurs constantes, les deux peuvent être utilisés
  • Pour les plages de valeurs, seul if est applicable
  • switch profite de la perméation pour exécuter plusieurs cas

4. Structures itératives

4.1 Introduction

public static void main(String[] args) {
    System.out.println("Apprendre dur, progresser chaque jour!");
    System.out.println("Apprendre dur, progresser chaque jour!");
    System.out.println("Apprendre dur, progresser chaque jour!");
    // ... répété 100 fois
}

Pour répéter une instruction 100 fois, plutôt que de l'écrire 100 fois, on utilise une boucle.

Catégories de boucles :

  • while
  • for
  • do...while

4.2 Boucle for

4.2.1 Syntaxe

for (expressionInitiale; conditionBoucle; instructionContrôle) {
    corpsBoucle;
}

Note : Les deux points-virgules sont obligatoires. La condition doit être de type boolean.

Flux d'exécution :

  1. Exécuter l'expression initiale
  2. Évaluer la condition (false = arrêt, true = continuer)
  3. Exécuter le corps de la boucle
  4. Exécuter l'insturction de contrôle
  5. Retour à l'étape 2

4.2.2 Exemple 1

public static void main(String[] args) {
    // Afficher 1-5
    for (int i = 1; i <= 5; i++) {
        System.out.println(i);
    }
    System.out.println("--------");
    // Afficher 5-1
    for (int i = 5; i >= 1; i--) {
        System.out.println(i);
    }
}

4.2.3 Exemple 2

public static void main(String[] args) {
    int somme = 0;
    for (int i = 1; i <= 5; i++) {
        somme += i;
    }
    System.out.println(somme);
}

4.2.4 Exemple 3

public static void main(String[] args) {
    int somme = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 2 == 0) {
            somme += i;
        }
    }
    System.out.println("Somme des nombres pairs entre 1 et 100 : " + somme);
}

4.2.5 Exemple 4

class Narcissistique {
    public static void main(String[] args) {
        for (int nb = 100; nb <= 999; nb++) {
            int unite = nb % 10;
            int diz = (nb / 10) % 10;
            int cent = nb / 100;
            if (unite*unite*unite + diz*diz*diz + cent*cent*cent == nb) {
                System.out.println("Nombre narcisse trouvé : " + nb);
            }
        }
    }
}

4.3 Boucle while

4.3.1 Syntaxe

instructionInitiale;
while (condition) {
    corpsBoucle;
    instructionContrôle;
}

4.3.2 Exemple 1

public static void main(String[] args) {
    int compteur = 1;
    while (compteur <= 10) {
        System.out.println("Bonjour le monde");
        compteur++;
    }
}

4.3.3 Exemple 2

public static void main(String[] args) {
    int nombre = 1;
    while (nombre <= 100) {
        if (nombre % 2 == 0) {
            System.out.println(nombre);
        }
        nombre++;
    }
}

4.4 Boucle do...while

4.4.1 Syntaxe

instructionInitiale;
do {
    corpsBoucle;
    instructionContrôle;
} while (condition);

Différence : La boucle s'exécute au moins une fois (évaluation après exécution).

4.4.2 Exemple 1

public static void main(String[] args) {
    int x = 1;
    do {
        System.out.println("Bonjour le monde");
        x++;
    } while (x <= 10);
}

4.4.3 Exemple 2

public static void main(String[] args) {
    do {
        System.out.println("Exécution garantie une fois");
    } while (false);
}

4.4.4 Exemple 3

public static void main(String[] args) {
    int nombre = 1;
    int somme = 0;
    int compteur = 0;

    do {
        if (nombre % 2 == 0) {
            System.out.println(nombre);
            somme += nombre;
            compteur++;
        }
        nombre++;
    } while (nombre <= 100);

    System.out.println("Somme : " + somme);
    System.out.println("Nombre d'éléments : " + compteur);
}

4.5 Différences entre les trois boucles

  • for et while : Évaluation préalable (test avant exécution)
  • do...while : Évaluation après (exécution au moins une fois)
  • for vs while : La variable de contrôle dans for n'est pas accessible après la boucle, alors qu'elle l'est avec while
  • Utiliser for quand le nombre d'itérations est connu
  • Utiliser while quand le nombre d'itérations est inconnu

4.6 Boucle infinie

Une boucle infinie a une condition toujours vraie. Pour en sortir, utiliser une instruction break.

while (true) {}
for (;;) {}
do {} while (true);

4.7 Boucles imbriquées

4.7.1 Explication

Une boucle imbriquée contient une autre boucle dans son corps.

for (initialisation; condition; incrément) {
    // ...
    for (initialisation; condition; incrément) {
        instruction;
    }
    // ...
}

4.7.2 Exemple

public static void main(String[] args) {
    for (int ligne = 0; ligne < 5; ligne++) {
        for (int col = 0; col < 8; col++) {
            System.out.print("*");
        }
        System.out.println();
    }
}

5. Instructions de saut

5.1 Explication

Les instructions de saut permettent de modifier le flux d'exécution à l'intérieur des boucles.

5.2 break

5.2.1 Explication

L'instruction break permet de quitter immédiatement une boucle ou un switch.

5.2.2 Exemple

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
        if (i == 3) {
            break;
        }
        System.out.println("Bonjour " + i);
    }
}

5.3 continue

5.3.1 Explication

L'instruction continue permet de passer à l'itération suivante, en ignorant le reste du corps de la boucle.

5.3.2 Exemple 1

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
        if (i == 3) {
            continue;
        }
        System.out.println("Bonjour " + i);
    }
}

5.3.3 Exemple 2

public static void main(String[] args) {
    int somme = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 2 == 0) {
            continue;
        }
        somme += i;
    }
    System.out.println("Somme = " + somme);
}

Étiquettes: Java structures-conditionnelles boucle-if boucle-switch boucle-for

Publié le 8 juillet à 00h45

Étiquettes Populaires

©2026 L'Atelier Monstre