Programmation Java et boucle itérations

Pour faire des boucles de votre programme Java plus facile à écrire et plus facile à comprendre, vous devez savoir comment Java de pause

et continuer déclarations affectent itérations de la boucle.

La déclaration de rupture de Java

Jetez un coup d'oeil à le programme ci-dessous. Le programme génère au hasard un nombre de 1 à 10, et à plusieurs reprises demande à l'utilisateur de deviner ce nombre.

Annonce 1

static import-import java.util.Scanner java.lang.System.out-import java.util.Random-classe publique GuessAgain {void main (String args []) {public static Scanner clavier = new Scanner (System.in) - int numGuesses = 0-int randomNumber = new Random (). nextInt (10) + 1-out.println ("************") -out.println ("Bienvenue sur le jeu de devinettes ") -out.println (" ************ ") -out.println () - out.print (" Entrez un int entre 1 et 10: ") -int inputNumber = clavier. nextInt () - numGuesses ++ -while (inputNumber! = randomNumber) {out.println () - out.println ("Essayez de nouveau ...") - out.print ("Entrez un int entre 1 et 10:") -inputNumber = keyboard.nextInt () - numGuesses ++ -}out.print ("Vous gagnez après") -out.println (numGuesses + "suppositions.") - keyboard.close () -}}

La figure ci-dessous montre une course du code. L'utilisateur fait cinq suppositions. Chaque fois, l'ordinateur vérifie pour voir si la conjecture est correcte. Une supposition incorrecte génère une demande d'essayer à nouveau. Pour une estimation correcte, l'utilisateur reçoit un vibrant Tu as gagné, avec un décompte du nombre de suppositions qu'il ou elle fait. L'ordinateur est de répéter plusieurs déclarations maintes et maintes fois, vérifiant à chaque fois par l'intermédiaire de voir si la proposition de l'utilisateur est le même que le nombre généré de façon aléatoire. Chaque fois que l'utilisateur fait une proposition, l'ordinateur ajoute 1 à son décompte des suppositions. Lorsque l'utilisateur fait la bonne proposition, l'ordinateur affiche de la correspondance.

Quel est maladroit sur ce programme? Eh bien, quelques déclarations apparaissent plusieurs fois dans le programme. Normalement, une déclaration qui est copié à partir d'une partie d'un programme à l'autre est à aucune préoccupation. Mais, la stratégie globale semble suspect. Le programme obtient un numéro de l'utilisateur avant la boucle et (encore) à l'intérieur de la boucle.

out.print ("Entrez un int entre 1 et 10:") -int inputNumber = keyboard.nextInt () -numGuesses ++ -while (inputNumber = randomNumber!) {out.println () - out.println ("Essayez de nouveau ...") -out.print ("Entrez un int entre 1 et 10:") -inputNumber keyboard.nextInt = () -numGuesses ++ -}

Ce code utilise une astuce standard pour faire des boucles travail. C'est appelé amorçage une boucle. Le motif est

Obtenez entréetandis que l'entrée que vous avez est pas la dernière entrée{ Obtenez plus d'entrée}

Au début de la tandis que boucle, l'ordinateur vérifie une condition ayant à voir avec l'entrée de l'utilisateur. Donc, l'ordinateur ne passe pas en boucle jusqu'à ce que l'utilisateur donne une entrée. Puis, quand l'ordinateur est à l'intérieur de la boucle, l'ordinateur demande pour plus d'entrée pour nourrir prochaine itération de la boucle. L'astuce semble étrange, mais il fonctionne.

Les développeurs utilisent cette technique, amorçant une boucle, tout le temps, donc il ne peut pas être si mal que ça. Mais il est une autre façon.

Listing 2

static import-import java.util.Scanner java.lang.System.out-import java.util.Random-classe publique GuessAgain {void main (String args []) {public static Scanner clavier = new Scanner (System.in) - int inputNumber, numGuesses = 0-int randomNumber = new Random (). nextInt (10) + 1-out.println ("************") -out.println ("Bienvenue à la jeu de devinettes ") - out.println (" ************ ") -out.println () -while (true) {out.print ("Entrez un int entre 1 et 10:") -inputNumber = keyboard.nextInt () - numGuesses ++ -si (== inputNumber randomNumber) {percée}out.println () - out.println ("Essayez de nouveau ...") -}out.print ("Vous gagnez après") -out.println (numGuesses + "suppositions.") - keyboard.close () -}}

Du point de vue de l'utilisateur, le code du listing 2 fait exactement la même chose que le code du listing 1. (Pour voir la sortie des deux programmes, reportez-vous à la figure ci-dessus.) La différence est le Listing 2 ne dispose que d'un appel à keyboard.nextInt. Cet appel est à l'intérieur de la boucle, l'ordinateur doit donc entrer dans la boucle sans tester toute entrée.

Si vous regardez l'état de la boucle, vous pouvez voir comment cela fonctionne. L'état de la boucle est toujours vrai. Peu importe ce qui se passe, l'état de la boucle passe toujours son test. Donc, l'état de la boucle est une grande fraude. Vous ne sautez hors de la boucle en omettant le test de l'état de la boucle. Au lieu de cela, vous sautez quand vous frappez la pause déclaration qui est à l'intérieur de la boucle (et que vous frappez pause déclaration lorsque vous avez passé le si (== inputNumber randomNumber) barrage). Le tout fonctionne très bien.

Lorsque l'ordinateur exécute un pause déclaration qui est dans une boucle, l'ordinateur saute hors de la boucle (à la première instruction qui vient après la boucle).

Avec un pause déclaration, l'ordinateur saute sur une seule boucle. Si cette boucle se trouve être dans une autre boucle (un de boucle externe) de l'ordinateur ne saute pas hors de la boucle externe.

public class BreakOutOfLoop {static void main (String [] args) {publicsfor (int i = 0 à i lt; 3- i ++) {for (int j = 0- j lt; 100- j ++) {System.out.print (j + "") -Si (j> 9) {} percée}System.out.println ("Je éclaté!") -}}}

Pour illustrer, la figure suivante contient la sortie du code précédent:

Lorsque l'ordinateur atteint le pause déclaration, le contrôle passe à la Je éclaté déclaration. Cette Je éclaté déclaration est dehors du J boucle mais il est à l'intérieur la pour i boucle.

Du point de vue du programmeur, le code du listing 2 est plus naturel que le code du listing 1. Après tout, comment ne le jeu procéder? Les hypothèses de l'utilisateur, puis l'ordinateur vérifie la conjecture, et ensuite (si la conjecture est pas correct) l'ordinateur dit «Essayez à nouveau." Voilà la séquence des événements, comme décrit dans le Listing 2. Mais dans le listing 1, le code de la boucle semble décrire les événements dans l'ordre inverse: La boucle dit "Try Again", puis l'utilisateur saisit un certain nombre.

Listing 2 offre une belle alternative à la technique de boucle d'amorçage dans le listing 1. Alors pourquoi ne programmeurs peine à amorcer leurs boucles? Faire pause états ont des inconvénients cachés? Eh bien, la réponse dépend de votre point de vue. Certains programmeurs pensent que pause déclarations dans les boucles sont source de confusion. Tout le saut de déclaration à la déclaration rend le vertige et leur rappelle de quelque chose des années 1960 appelé code spaghetti. (Utilisations de code spaghetti aller à déclarations de sauter d'une déclaration à l'autre. Dans Pascal par exemple, Auteur B. Burd dit “ Programmation avec goto est comme un voyage autour de Paris à la nage à travers son réseau d'égouts. Il ya beaucoup de raccourcis, mais aucun d'entre eux méritent d'être pris ”). Une façon ou d'une autre, pause déclarations dans les boucles sont l'exception, pas la règle. Utilisez-les si vous voulez, mais ne vous attendez pas à trouver beaucoup d'entre eux dans le code Java d'autres personnes.

Continuer la déclaration de Java

Listing 3 propose plus de sauce secrète pour les boucles de votre programme. Imaginez un jeu qui génère aléatoirement trois numéros de 1 à 20. L'utilisateur prend cinq tours de deviner les numéros. Lorsque l'utilisateur entre une estimation correcte, le programme félicite l'utilisateur. ("Bien deviné," dit le programme.) Lorsque l'utilisateur entre une supposition erronée, le programme fournit aucune rétroaction.

Liste 3 contient un code pour rendre tout cela possible.

Liste 3

static import-import java.util.Scanner java.lang.System.out-import java.util.Random-classe publique GuessAgainAndAgain {void main (String args []) {public static Scanner clavier = new Scanner (System.in) - int inputNumber-int randNum1 = new Random (). nextInt (20) + 1 int randNum2 = new Random (). nextInt (20) + 1 int randNum3 = new Random (). nextInt (20) + 1-out. println ("************") -out.println ("Bienvenue sur le jeu de devinettes") - out.println ("************") -out.println () - for (int i = 0 à i lt; 5- i ++) {out.print ("Entrez un int:") -inputNumber = keyboard.nextInt () -si (inputNumber! = randNum1  inputNumber! = randNum2 inputNumber! = randNum3) {continue-}out.println ("Bien deviné!") - out.println () -} out.print ("Les chiffres sont") -out.print (randNum1 + "") -out.print (randNum2 + "") départ privé .print (randNum3 + "") -keyboard.close () -}}

Cette figure montre une course d'un tel programme.

Java de continuer déclaration indique à l'ordinateur de sauter au-delà des déclarations restant à l'intérieur de la boucle. Autrement dit, au lieu d'exécuter les instructions restantes à l'intérieur de la boucle, l'ordinateur passe au début de la prochaine itération de la boucle. Donc, dans le Listing 3, lorsque le inputNumber est pas des numéros générés au hasard du programme, l'ordinateur saute passé le code "Bon conjecture", incrémente le compteur de boucle (la variable je), Et demande à l'utilisateur pour une autre valeur d'entrée. (Bien sûr, si le compteur de boucle atteint sa limite, l'ordinateur ne pas exécuter une autre itération. Au lieu de cela, l'ordinateur saute hors de la boucle, et exécute toute déclaration vient après la boucle.)

Vous pouvez facilement réécrire Listing 3 afin que le code n'a pas continuer déclaration. Vous auriez à mettre le code "Bon conjecture" l'intérieur d'un si déclaration, mais ce serait bien. La continuer déclaration ne fait pas beaucoup pour améliorer l'apparence de la liste de programme 3. Mais quand vous voulez éviter le code de nidification à l'intérieur si déclarations, le continuer déclaration est très pratique.

Peut-être, dans votre application, le reste de la boucle est une séquence complexe de déclarations. Vous ne voulez pas faire cette séquence semble plus compliqué en l'enfermant à l'intérieur d'un si déclaration. Ou peut-être, dans votre application, vous sautez rarement le reste de la boucle, et que vous souhaitez mettre l'accent sur cette rareté en ne joignant le reste de la boucle dans un si déclaration. Dans les deux cas, un continuer déclaration pourrait être exactement le bon choix.