Opérateurs de saut

Java prend en charge trois opérateurs de saut - break, continueet return. Ils transfèrent le contrôle à une autre partie de votre programme. Examinons chacun des opérateurs en détail.

Utilisation de l'opérateurbreak

L'opérateur breaken Java est utilisé dans trois cas. Premièrement, comme vous l'avez déjà vu, cela termine la séquence d'instructions au niveau des branches d'instructions switch. Deuxièmement, il peut être utilisé pour sortir d’une boucle. Troisièmement, il peut être utilisé comme une forme « civilisée » de l'opérateur de saut inconditionnel goto. Cette section explique les deux derniers cas. Utiliser breakpour quitter une boucle En utilisant break, vous pouvez forcer la fin immédiate de la boucle, en contournant l'expression conditionnelle et tout code restant dans le corps de la boucle. Lorsqu'une instruction breakest rencontrée dans une boucle, la seconde se termine et le contrôle du programme est transféré à l'instruction qui la suit. Exemple simple :

// Использование break для выхода из цикла.
public class BreakLoop {

  public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
      if (i == 4) {
        break; // завершить цикл, если i = 4
      }
      System.out.println("i: " + i);
    }
    System.out.println("Цикл завершен.");
  }
}

Ce programme génère le résultat suivant :

i: 0
i: 1
i: 2
i: 3
Цикл завершен.

Bien que la boucle forsoit conçue ici pour exécuter ses instructions de 0 à 99 fois, l'opérateur breakla fait se terminer plus tôt lorsque i vaut 4. L'opérateur breakpeut être utilisé avec n'importe quelle boucle Java, y compris les boucles intentionnellement infinies. Par exemple, ci-dessous se trouve le programme précédent codé à l’aide d’une boucle while. Le résultat de ce programme est le même que celui de son prédécesseur.

// Использование break для выхода из while-цикла.
public class BreakLoop2 {

  public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
      if (i == 4) {
        break; // закончить цикл, если i = 4
      }
      System.out.println("i: " + i);
      i++;
    }
    System.out.println("Цикл завершен.");
  }
}

Lorsqu'elle est utilisée dans un ensemble de boucles imbriquées, l'instruction breakne quittera que la boucle la plus interne. Par exemple:

// Использование break во вложенных циклах.
public class BreakLoop3 {

  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 10; j++) {
        if (j == 4) {
          break; // закончить цикл, если j = 4
        }
        System.out.print(j + " ");
      }
      System.out.println();
    }
    System.out.println("Цикл завершен.");
  }
}

Ce programme génère le résultat suivant :

Итерация 0: 0 1 2 3
Итерация 1: 0 1 2 3
Итерация 2: 0 1 2 3
Цикл завершен.

Comme vous pouvez le voir, l'instruction breakdans la boucle interne entraîne uniquement la fin de cette boucle. La boucle externe n'est pas affectée. Faisons encore deux commentaires concernant break. Premièrement, plusieurs instructions peuvent apparaître dans une boucle break. Soyez toutefois prudent. Un trop grand nombre d’entre eux ont tendance à déstructurer votre code. Deuxièmement, le break, qui termine l' -instruction switchaffecte uniquement l' -instruction switch(et non les boucles qui l'incluent). Commentaire: Breakn'a pas été conçu comme moyen normal de terminaison de boucle. Cet objectif est atteint par l’expression conditionnelle d’en-tête de boucle. L'opérateur breakne doit être utilisé pour rompre la boucle que lorsque certaines situations particulières se présentent.

Utiliser breakcomme formulairegoto

En plus d'être utilisé dans les instructions switch et les boucles, breakil peut également être utilisé seul comme forme « civilisée » du goto. Java ne contient pas l'opérateur gotocar il effectue le branchement de manière arbitraire et non structurée. Le code qui utilise .de manière intensive gotoest généralement difficile à comprendre et à maintenir. Il remplace également certaines optimisations du compilateur. Il existe cependant plusieurs endroits dans un programme où gotole flux de contrôle est une construction précieuse et légitime. Par exemple, gotocela peut être utile lorsque vous sortez d’un ensemble de boucles profondément imbriquées. Pour gérer de telles situations, Java définit une forme étendue de l'opérateur break. En l'utilisant, vous pouvez quitter un ou plusieurs blocs de code. Ces blocs n'ont pas besoin de faire partie d'une boucle ou d'une instruction switch. Cela peut être n’importe quel bloc. Ensuite, vous pouvez déterminer exactement où l'exécution se poursuivra car ce formulaire breakfonctionne avec la marque et offre les avantages de goto, en contournant ses problèmes. Une breakinstruction étiquetée a la forme générale suivante : break label; Voici labelle nom d'une étiquette qui identifie un bloc de code. Lorsque ce formulaire breakest exécuté, le contrôle est transféré du bloc de code nommé (dont l'étiquette est spécifiée dans l'instruction break) à l'instruction qui suit ce bloc. Un bloc de code marqué doit nécessairement inclure cette instruction break, mais il n'est pas nécessaire que cette inclusion soit directe (c'est-à-dire qu'elle breakpeut être incluse non pas directement dans un bloc avec sa propre étiquette, mais dans un bloc imbriqué à l'intérieur de celui-ci, éventuellement également marqué ). Cela signifie que vous pouvez utiliser un opérateur marqué breakpour échapper à un ensemble de blocs imbriqués. Mais vous ne pouvez pas utiliser breakun bloc de code qui n’inclut pas de fichier break. Pour nommer un bloc, placez une étiquette au début du bloc (avant l’accolade ouvrante). Une étiquette est un identifiant Java valide suivi de deux points. Après avoir étiqueté un bloc, son étiquette peut être utilisée comme argument pour l'opérateur break. Cela entraînera la poursuite de l’exécution à partir de la fin du bloc marqué. Par exemple, le programme suivant contient trois blocs imbriqués, chacun avec sa propre étiquette. L'opérateur breakavance, au-delà de la fin du bloc marqué de l'étiquette second, en sautant deux opérateurs println().

// Использование break How цивorзованной формы goto.
public class Break {

  public static void main(String[] args) {
    boolean t = true;
    first:
    {
      second:
      {
        third:
        {
          System.out.println("Перед оператором break.");
          if (t) {
            break second; // выход из блока second
          }
          System.out.println("Данный оператор никогда не выполнится");
        }
        System.out.println("Данный оператор никогда не выполнится ");
      }
      System.out.println("Данный оператор размещен после блока second.");
    }
  }
}

L'exécution de ce programme génère le résultat suivant :

Перед оператором break.
Данный оператор размещен после блока second.

L’une des utilisations les plus courantes de l’opérateur étiqueté breakconsiste à échapper aux boucles imbriquées. Par exemple, dans le programme suivant, la boucle externe n'est exécutée qu'une seule fois :

// Использование break для выхода из вложенных циклов.
public class BreakLoop4 {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 100; j++) {

        if (j == 10) {
          break outer; // выйти из обоих циклов
        }
        System.out.print(j + " ");
      }
      System.out.println("Эта строка никогда не будет выведена");
    }
    System.out.println("Цикл завершен.");
  }
}

Le programme génère la sortie suivante :

Итерация 0: 0 1 2 3 4 5 6 7 8 9 Цикл завершен.

Il est facile de voir que lorsque la boucle interne est interrompue avant la fin de la boucle externe, les deux boucles se terminent. Gardez à l'esprit que vous ne pouvez pas effectuer breakde saut vers une étiquette qui n'est pas définie pour le bloc englobant. Par exemple, le programme suivant n'est pas valide et ne sera pas compilé :

// Эта программа содержит ошибку.
public class BreakErr {

  public static void main(String[] args) {
    one:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
    }
    for (int j = 0; j < 100; j++) {
      if (j == 10) {
        break one; //He верно!
      }
      System.out.print(j + " ");
    }
  }
}

Étant donné qu'une boucle marquée un n'inclut pas d'instruction break, il n'est pas possible de transférer le contrôle à ce bloc.

Utilisation de l'opérateurcontinue

Parfois, il est utile de démarrer tôt la prochaine itération d’une boucle. Autrement dit, vous devez continuer à exécuter la boucle, mais arrêter de traiter le reste du code dans son corps pour cette itération particulière. En fait, il s'agit d'une gototransition entre les opérations suivantes du corps et la fin du bloc de boucle. Cette action est effectuée par l'opérateur continue. Dans les boucles, l' opérateur whileand provoque le transfert du contrôle directement à l'expression conditionnelle qui contrôle la boucle. Dans une boucle, le contrôle passe d’abord à la partie itérative de l’instruction puis à l’expression conditionnelle. Pour les trois boucles, tout code intermédiaire est contourné. Un exemple de programme permettant d'imprimer deux nombres sur chaque ligne est donné ci-dessous : do whilecontinueforforcontinue

// Демонстрирует continue.
public class Continue {

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

Ce code utilise l'opération %(modulo) pour vérifier si quelque chose est ipair. Si tel est le cas, la boucle continue sans imprimer de caractère de nouvelle ligne. Résultat du programme :

0 1
2 3
4 5
6 7
8 9

Comme avec l'opérateur break, , continuevous pouvez définir une étiquette indiquant quelle boucle englobante continuer. Un exemple de programme qui permet continued'imprimer une table de multiplication triangulaire de 0 à 9.

// Использование continue с меткой.
public class ContinueLabel {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 10; i++) {
      for (int j = 0; j < 10; j++) {
        if (j > i) {
          System.out.println();
          continue outer;
        }
        System.out.print(" " + (i * j));
      }
    }
    System.out.println();
  }
}

L'instruction continuede cet exemple termine la boucle en évaluant jet continue avec l'itération suivante de la boucle pilotée par i. Résultat de ce programme :

0
 0 1
 0 2 4
 0 3 6 9
 0 4 8 12 16
 0 5 10 15 20 25
 0 6 12 18 24 30 36
 0 7 14 21 28 35 42 49
 0 8 16 24 32 40 48 56 64
 0 9 18 27 36 45 54 63 72 81

C'est extrêmement rarement utile continue. L'une des raisons à cela est que Java fournit un riche ensemble d'instructions de boucle qui conviennent à la plupart des applications. Cependant, pour les situations particulières dans lesquelles il est nécessaire de terminer l'itération plus tôt, l'instruction continuefournit une manière structurée d'accomplir cette tâche.

Opérateurreturn

La dernière instruction de contrôle est return. Il est utilisé pour revenir explicitement d'une méthode, c'est-à-dire qu'il transfère le contrôle du programme au programme appelant. L'opérateur returnest classé comme opérateur de transition. Bien que sa discussion complète doive attendre que les méthodes soient discutées, un bref aperçu est fourni ici return. L'opérateur returnpeut être utilisé n'importe où dans une méthode pour revenir au programme appelant la méthode. L'instruction returnmet immédiatement fin à l'exécution de la méthode dans laquelle elle se trouve. L’exemple suivant illustre cela :

// Демонстрирует return.
public class Return {

  public static void main(String[] args) {
    boolean t = true;
    System.out.println("Перед оператором return.");
    if (t) {
      return; // возврат в вызывающую программу
    }
    System.out.println("Этот оператор никогда не выполнится.");
  }
}

Cela returnrevient au système Java au moment de l'exécution, puisque c'est le système qui appelle le main(). Résultat de ce programme :

Перед оператором return.

Vous remarquerez peut-être que l'instruction finale println()n'est pas exécutée. Au moment de l'exécution, returnle contrôle est transféré au programme appelant. Une dernière remarque. Dans le programme précédent, l' ifopérateur (t) est nécessaire. Sans cela, le compilateur Java générerait une erreur « code inaccessible » car il saurait que la dernière instruction println()ne serait jamais exécutée. Pour éviter cette erreur, l'opérateur (t) est utilisé if; il trompe le compilateur pour le besoin de cette démonstration. Lien vers la source originale : Opérateurs de transition