Instruction de branchement
Les instructions de branchement permettent d'interrompre le déroulement normal du programme en faisant un saut d'un endroit du programme vers un autre endroit. C'est pourquoi on les appelle également instructions de saut. Il y a trois instructions de branchement en Java : les instructions break, continue et return. Les deux premières sont traitées dans ce chapitre et la troisième est présentée au chapitre 5.
Instruction break
Nous avons déjà rencontré l'instruction break lorsqu'on a vu l'instruction switch au début de ce chapitre. En plus d'être utilisable avec cette dernière, elle peut également être utilisée dans le corps de n'importe quelle boucle.
L'instruction break a en fait pour effet de directement quitter le switch ou la boucle et de poursuivre le programme à l'instruction suivante. Voici un exemple de programme qui affiche les entiers de 1 à 5 et qui utilise l'instruction break :
La boucle while est une boucle infinie. En effet, la variable cnt est initialisée à 0 et tout ce qu'on fait avec, c'est incrémenter sa valeur de 1. Sa valeur sera donc toujours plus grande ou égale à 0 et la condition du while sera donc toujours satisfaite. Maintenant, dans le corps de la boucle, on utilise l'instruction break si la valeur de la variable cnt est strictement plus grande que 5, la boucle va donc s'arrêter et on n'aura pas de boucle infinie. La figure 19 montre le déroulement de l'exécution du programme. Vous voyez bien que l'instruction break quitte directement la boucle dans laquelle elle se trouve.
while contenant une instruction break.Notez que dans le cas des boucles, il est toujours possible de se passer de l'instruction break et d'écrire une boucle équivalente sans break, c'est-à-dire une boucle qui produit exactement le même résultat.
De manière générale, on préfère éviter d'utiliser l'instruction break car elle rend le code beaucoup plus complexe à comprendre, son exécution pouvant sauter d'un point à un autre du programme, potentiellement éloignés. Il est également plus difficile de raisonner sur des boucles contenant des break, pour vérifier si des boucles infinies sont possibles ou non, par exemple. Il faut garder en tête que la manière naturelle pour une boucle de s'arrêter est lorsque sa condition passe à false.
Retour sur l'instruction switch
Revenons un moment sur l'instruction switch pour comprendre complètement son fonctionnement et l'intérêt d'utiliser l'instruction break. L'exécution d'une instruction switch se passe en fait ainsi : tout d'abord, l'expression est évaluée. Ensuite, les case sont examinés les uns à la suite des autres, du premier au dernier. Dès qu'un case correspondant à la valeur de l'expression est trouvé, toutes les instructions qui suivent, jusque la dernière du corps du switch sont exécutées. Si aucun case n'est trouvé et qu'il y a un default, toutes les instructions qui suivent le default jusqu'à la fin du switch sont exécutées.
L'intérêt du break est justement d'éviter l'exécution jusque la fin du corps du switch à chaque fois. Voyons un exemple pour bien comprendre :
L'exécution du programme affiche ceci à l'écran :
value vaut 1 ou 2
En effet, le case 1: correspond, et donc, l'instruction System.out.println ("value vaut 1 ou 2"); est exécutée. Ensuite, on arrive au break qui fait que le switch est directement quitté.
Prenons maintenant le cas où la valeur de la variable value est 3. Le case 3: correspond à la valeur de la variable; et donc, l'instruction System.out.println ("value vaut 3"); est exécutée. Ensuite, on passe à l'instruction suivante qui est System.out.println ("value vaut autre chose que 1, 2, 3"); et puis on atteint la fin du switch. L'exécution du programme affiche donc à l'écran :
value vaut 3 value vaut autre chose que 1, 2, 3
Instruction continue
L'instruction continue, utilisable uniquement dans les boucles, permet d'arrêter l'exécution de l'itération en cours et de passer directement à la suivante. Dans le cas des boucles while et do, on revient directement à la vérification de la condition et pour les boucles for, on va sur la partie mise à jour. Voici une boucle while avec une instruction continue :
Voici ce que l'exécution du programme affiche à l'écran :
-2 -1 1 2
Les entiers compris entre -2 et 2, sauf le 0, sont affichés à l'écran. En effet, une instruction if teste si la valeur de la variable cnt vaut 0. Dans ce cas, on utilise l'instruction continue qui passe directement à l'itération suivante; on retourne donc à la vérification de la condition et l'instruction System.out.println (cnt); n'est pas exécutée.
La figure 20 montre le déroulement du programme. L'instruction continue a donc comme rôle de « passer un tour » de boucle. Il est également toujours possible d'écrire une boucle équivalente sans utiliser l'instruction continue. Le programme suivant affiche également les entiers compris entre -2 et 2 sauf le zéro mais n'utilise pas de continue :
while contenant une instruction continue.Étiquette
Lorsqu'on a plusieurs boucles imbriquées les unes dans les autres, et qu'on utilise une instruction break ou continue dans la boucle interne (la boucle qui est à l'intérieur du corps de l'autre), seule cette dernière sera altérée, mais la boucle externe continuera. Grâce aux étiquettes, on peut préciser quelle boucle doit être affectée. Voyons un exemple avec deux boucles imbriquées :
L'exécution de ce programme affiche à l'écran :
0 , 0 0 , 1 0 , 2 1 , 0 1 , 1 1 , 2
La boucle externe va s'exécuter deux fois. En effet, on commence avec i qui vaut 0 et la boucle continue tant que i < 2. Comme la variable i est incrémentée de un à chaque boucle, on a bien un total de deux exécutions du corps de la boucle externe. En ce qui concerne la boucle interne, on a la variable j qui vaut 0 au début et qui est incrémentée à chaque passage dans la boucle. De plus, lorsque la valeur de la variable j devient strictement plus grande que deux, on a une instruction break qui va quitter la boucle interne.
Et si on ne voulait pas quitter la boucle interne, mais plutôt la boucle externe ? On peut le faire en utilisant les étiquettes. Une étiquette, c'est simplement un identificateur suivi du caractère deux-points ( : ). On ne peut placer une étiquette que juste avant le début d'une boucle.
Une fois les étiquettes définies, on peut les utiliser avec les instructions break et continue pour signaler à quelle boucle s'applique le saut à faire. Revoyons notre exemple pour que ce soit la boucle externe qui soit quittée au lieu de l'interne.
On a déclaré deux étiquettes externe: et interne: attachées à chacune des boucles de ce programme. Ensuite, on a défini que l'instruction break est liée à la boucle externe. Ainsi, lorsque celle-ci sera exécutée, ce sera la boucle externe qui sera quittée. En effet, on peut observer ceci à l'écran :
0 , 0 0 , 1 0 , 2