Instructions de saut : break, continue et return

Instructions de saut : break, continue et return

  Prérequis

Maîtriser les boucles (for, while, do-while) et la structure switch. Comprendre la notion de méthode et de valeur de retour.

  Objectifs

Comprendre et utiliser les trois instructions de saut Java : break, continue et return. Savoir les distinguer et les appliquer pour contrôler précisément le flux d'exécution d'un programme.

1. Vue d'ensemble

2. L'instruction break

2.1 break dans un switch

Sans break, l'exécution continue dans les case suivants (fall-through). Le break met fin au switch après l'exécution du cas correspondant.

  Exemple 1 — break dans un switch

public class BreakSwitch {
    public static void main(String[] args) {
        int jour = 3;

        switch (jour) {
            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("Jour invalide");
        }
    }
}

Mercredi

2.2 break dans une boucle

  Exemple 2 — Sortir d'une boucle for avec break

public class BreakBoucle {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 3) {
                break; // on quitte la boucle dès que i vaut 3
            }
            System.out.println("i = " + i);
        }
        System.out.println("Après la boucle");
    }
}

i = 0
i = 1
i = 2
Après la boucle

2.3 break dans une boucle imbriquée

  Exemple 3 — break dans une boucle imbriquée

public class BreakImbriquee {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == 1) {
                    break; // quitte uniquement la boucle interne (j)
                }
                System.out.println("j = " + j);
            }
            System.out.println("i = " + i);
        }
    }
}

j = 0
i = 0
j = 0
i = 1
j = 0
i = 2

2.4 break étiqueté — sortir de plusieurs boucles imbriquées

etiquette: {
    // bloc ou boucle
    break etiquette; // saute à la fin du bloc étiqueté
}

  Exemple 4 — break étiqueté (équivalent goto)

public class BreakLabel {
    public static void main(String[] args) {
        int i = 4;

        bloc1: {
            bloc2: {
                System.out.println("début bloc2");
                if (i == 4) {
                    break bloc1; // saute directement à la fin de bloc1
                }
                System.out.println("fin bloc2"); // jamais atteint
            }
            System.out.println("fin bloc1"); // jamais atteint
        }
        System.out.println("fin du programme");
    }
}

début bloc2
fin du programme

  Exemple 5 — Sortir de deux boucles imbriquées avec étiquette

public class BreakLabelBoucle {
    public static void main(String[] args) {
        // Rechercher la position de la valeur 5 dans une matrice
        int[][] matrice = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int ligne = -1, colonne = -1;

        recherche: // étiquette sur la boucle externe
        for (int i = 0; i < matrice.length; i++) {
            for (int j = 0; j < matrice[i].length; j++) {
                if (matrice[i][j] == 5) {
                    ligne    = i;
                    colonne  = j;
                    break recherche; // quitte les DEUX boucles
                }
            }
        }
        System.out.println("Trouvé à [" + ligne + "][" + colonne + "]");
    }
}

Trouvé à [1][1]

3. L'instruction continue

  Exemple 6 — Sauter une valeur avec continue

public class ContinueEx {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                continue; // saute l'affichage pour i == 2
            }
            System.out.println("i = " + i);
        }
    }
}

i = 0
i = 1
i = 3
i = 4

3.1 continue étiqueté

Comme break, continue peut être combiné avec une étiquette pour passer à l'itération suivante d'une boucle externe depuis une boucle interne.

  Exemple 7 — continue étiqueté sur boucle externe

public class ContinueLabel {
    public static void main(String[] args) {
        // Afficher uniquement les paires (i,j) où i != j
        externe:
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i == j) {
                    continue externe; // passe à l'itération suivante de i
                }
                System.out.println("(" + i + ", " + j + ")");
            }
        }
    }
}

(1, 0)
(2, 0)
(2, 1)

3.2 Comparaison break vs continue

  Exemple 8 — Comparaison côte à côte

// Avec break — s'arrête à i == 3
System.out.println("--- break ---");
for (int i = 0; i < 6; i++) {
    if (i == 3) break;
    System.out.print(i + " ");
}
// Sortie : 0 1 2

System.out.println("\n--- continue ---");
// Avec continue — saute i == 3, poursuit jusqu'à 5
for (int i = 0; i < 6; i++) {
    if (i == 3) continue;
    System.out.print(i + " ");
}
// Sortie : 0 1 2 4 5

--- break ---
0 1 2
--- continue ---
0 1 2 4 5

4. L'instruction return

// Méthode sans valeur de retour (void)
return;

// Méthode avec valeur de retour
return expression;

  Exemple 9 — return pour quitter un main()

public class ReturnEx {
    public static void main(String[] args) {
        int i = 2;

        if (i == 2) {
            System.out.println("i vaut 2 — on quitte.");
            return; // termine main() ici
        }

        // Cette ligne n'est jamais atteinte si i == 2
        System.out.println("Fin normale du programme.");
    }
}

i vaut 2 — on quitte.

  Exemple 10 — return dans une méthode avec valeur de retour

public class ReturnValeur {

    // Méthode qui retourne le maximum de deux entiers
    static int max(int a, int b) {
        if (a > b) {
            return a; // return anticipé
        }
        return b;     // return en fin de méthode
    }

    // Méthode qui vérifie si un entier est premier
    static boolean estPremier(int n) {
        if (n < 2) return false;
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) return false; // sortie anticipée si divisible
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println("max(5, 9) = " + max(5, 9));
        System.out.println("7 est premier ? " + estPremier(7));
        System.out.println("9 est premier ? " + estPremier(9));
    }
}

max(5, 9) = 9
7 est premier ? true
9 est premier ? false

// Style avec early return — plus lisible
static double diviser(double a, double b) {
    if (b == 0) return 0; // cas particulier traité en premier
    return a / b;
}

// Style avec if-else imbriqué — moins lisible
static double diviser2(double a, double b) {
    if (b != 0) {
        return a / b;
    } else {
        return 0;
    }
}

static int exemple() {
    return 42;
    System.out.println("jamais atteint"); // Erreur : code mort
}

5. Exercice

Premier négatif : -1
Valeurs positives : 4 7 5

public class InstructionsSaut {

    // ── Méthode 1 : chercher le premier négatif ───────────
    static int chercherPremierNegatif(int[] T) {
        int resultat = 0; // valeur par défaut si aucun négatif
        for (int val : T) {
            if (val < 0) {
                resultat = val;
                break; // on s'arrête dès la première valeur négative
            }
        }
        return resultat; // return renvoie le résultat à l'appelant
    }

    // ── Méthode 2 : afficher les positifs ─────────────────
    static void afficherPositifs(int[] T) {
        System.out.print("Valeurs positives : ");
        for (int val : T) {
            if (val <= 0) {
                continue; // ignorer zéro et les négatifs
            }
            System.out.print(val + " ");
        }
        System.out.println(); // retour à la ligne final
    }

    // ── Programme principal ───────────────────────────────
    public static void main(String[] args) {
        int[] T = {4, -1, 7, 0, -3, 5};

        int neg = chercherPremierNegatif(T);
        if (neg != 0) {
            System.out.println("Premier négatif : " + neg);
        } else {
            System.out.println("Aucune valeur négative trouvée");
        }

        afficherPositifs(T);
    }
}

Premier négatif : -1
Valeurs positives : 4 7 5

  L'essentiel en bref

Java dispose de trois instructions de saut. break quitte immédiatement la boucle ou le switch courant ; combiné avec une étiquette, il permet de sortir de plusieurs niveaux de boucles imbriquées en une seule instruction. continue saute le reste de l'itération courante et passe à la suivante, sans quitter la boucle ; il accepte lui aussi une étiquette pour cibler une boucle externe. return termine la méthode courante et retourne une valeur à l'appelant ; son usage anticipé (early return) simplifie la gestion des cas particuliers et réduit l'imbrication.