Java Programmering och Loop Iterations - dummies

För att göra ditt Java-program slingor enklare att skriva och lättare att förstå, behöver du veta hur Java: s paus och fortsättande uttalanden påverkar loop-iterationer.

Java's break statement

Ta en gander på programmet nedan. Programmet genererar slumpmässigt ett tal från 1 till 10, och uppmanar upprepade gånger användaren att gissa det numret.

Listing 1

importera statisk java. lang. Systemet. ut; importera java. util. Scanner; importera java. util. Slumpmässig; offentlig klass GuessAgain {public static void main (String args []) {Skannertangentbord = ny Scanner (System. in); int numGuesses = 0; int randomNumber = nytt slumpmässigt (). nextInt (10) + 1; ut. println ("************"); ut. println ("Välkommen till gissningsspelet"); ut. println ("************"); ut. println (); ut. skriv ut ("Ange ett int från 1 till 10:"); int inputNumber = tangentbord. nextInt (); numGuesses ++; medan (inputNumber! = RandomNumber) { ut. println (); ut. println ("Försök igen …"); ut. skriv ut ("Ange ett int från 1 till 10:"); inputNumber = tangentbord. nextInt (); numGuesses ++; } ut. skriv ut ("Du vinner efter"); ut. println (numGuesses + "guesses."); tangentbord. stäng ();}}

Figuren nedan visar en körning av koden. Användaren gör fem gissningar. Varje gång kontrollerar datorn att se om gissningen är korrekt. En felaktig gissning genererar en begäran om att försöka igen. För en korrekt gissning får användaren en rousing Du vinner, tillsammans med en räkning av antalet gissningar han eller hon gjorde. Datorn upprepar flera uttalanden om och om igen, kontrollerar varje gång genom att se om användarens gissning är densamma som det slumpmässigt genererade numret. Varje gång användaren gör en gissning lägger datorn 1 till sin gissning. När användaren gör rätt gissning visar datorn den som talt.

Vad är obehagligt om detta program? Tja, några uttalanden förekommer mer än en gång i programmet. Normalt är ett uttalande som kopieras från en del av ett program till ett annat ingen anledning till oro. Men den övergripande strategin verkar misstänksam. Programmet får ett nummer från användaren före slingan och (igen) inuti slingan.

ut. skriv ut ("Ange ett int från 1 till 10:"); int inputNumber = tangentbord. nextInt (); numGuesses ++; medan (inputNumber! = RandomNumber) {out. println (); ut. println ("Försök igen …"); ut. skriv ut ("Ange ett int från 1 till 10:"); inputNumber = tangentbord. nextInt (); numGuesses ++; }

Den här koden använder ett standardtrick för att göra loopar arbete. Det kallas priming en slinga. Mönstret är

Få inmatning medan den ingång du har är inte den sista ingången { Få mer ingång }

I början av stundslingan, kontrollerar datorn ett tillstånd som har att göra med användarens inmatning. Så går inte datorn in i slingan tills användaren ger lite ingång. Sedan när datorn är inne i slingan frågar datorn efter mer inmatning för att mata slingens nästa iteration. Tricket verkar konstigt, men det fungerar.

Utvecklare använder den här tekniken, priming en loop, hela tiden, så det kan inte vara så illa. Men det finns ett annat sätt.

Lista 2

importera statisk java. lang. Systemet. ut; importera java. util. Scanner; importera java. util. Slumpmässig; offentlig klass GuessAgain {public static void main (String args []) {Skannertangentbord = ny Scanner (System. in); int inputNumber, numGuesses = 0; int randomNumber = nytt slumpmässigt (). nextInt (10) + 1; ut. println ("************"); ut. println ("Välkommen till gissningsspelet"); ut. println ("************"); ut. println (); medan (sant) { ut. skriv ut ("Ange ett int från 1 till 10:"); inputNumber = tangentbord. nextInt (); numGuesses ++; om (inputNumber == randomNumber) { break; } ut. println (); ut. println ("Försök igen …"); } ut. skriv ut ("Du vinner efter"); ut. println (numGuesses + "guesses."); tangentbord. nära ();}}

Från användarens synvinkel gör koden i Listing 2 exakt samma sak som koden i Listning 1. (För att se produktionen av något program, se figuren ovan.) skillnad är Listing 2 har bara ett samtal till tangentbordet. nextInt. Det samtalet är inne i slingan, så datorn måste gå in i slingan utan att testa någon ingång.

Om du tittar på slingans skick kan du se hur det fungerar. Slingans skick är alltid sant. Oavsett vad som händer, går slingens skick alltid sitt test. Så slingans skick är ett stort bedrägeri. Du hoppar aldrig ut ur slingan genom att misslyckas med testet i slingans skick. I stället hoppar du ut när du slår break-uttalandet som ligger inne i slingan (och du slår det slutsatsen när du kommer förbi blockblocket if (inputNumber == randomNumber). Hela saken fungerar väldigt snyggt.

När datorn exekverar ett pausdeklaration som sitter i en slinga hoppar datorn ut ur slingan (till det första uttalandet som kommer efter slingan).

Med ett pausutdrag hoppar datorn ut ur en enda slinga. Om den slingan råkar vara inuti en annan slinga (en yttre slinga) hoppa inte datorn utanför den yttre slingan.

allmän klass BreakOutOfLoop {Stats [] args) { för (int i = 0; i <3; i ++) { för (int j = 0; j <100; j ++) { System. ut. skriva ut (j + ""); om (j> 9) {break;} } System. ut. println ("Jag bröt ut!"); } }}

För att illustrera innehåller följande figur utgången från föregående kod:

När datorn når brytningsdeklarationen hoppar kontrollen till jag slog ut uttalandet.Att jag bröt ut uttalandet är utanför av j-slingan men det är inuti för slingan.

Från programmörens synvinkel är koden i Listning 2 mer naturlig än koden i Listing 1. Hur går spelet vidare? Användaren gissar, då kontrollerar datorn gissningen, och då (om gissningen inte är korrekt) säger datorn "Försök igen. "Det är sekvensen av händelser som beskrivs i Listing 2. Men i Listing 1 verkar koden i slingan beskriva händelserna i omvänd ordning: Slingan säger" Försök igen "och sedan matar användaren ett nummer.

Listing 2 erbjuder ett bra alternativ till loop-priming-tekniken i Listing 1. Så varför programmerar programmor att pröva sina loopar? Har break uttalanden har några dolda nackdelar? Tja, beror svaret på din synvinkel. Vissa programmerare tror att slutsatser i loopar är förvirrande. Allt hoppande från uttalande till uttalande gör dem yr och påminner dem om något från 1960-talet som heter spagetti-kod . (Spaghetti-kod använder goto-uttalanden för att hoppa från ett uttalande till ett annat. I Pascal genom Exempel säger författaren B. Burd "Programmering med Goto är som att resa runt Paris genom att simma genom sitt avloppssystem. korta nedskärningar, men ingen av dem är värda att ta. ") På ett eller annat sätt bryts uttalanden i loopar är undantaget, inte regeln. Använd dem om du vill, men förvänta dig inte att hitta många av dem i andras Java-kod.

Java: s fortsatta uttalande

Listing 3 erbjuder mer hemlig sås för programmets loopar. Tänk dig ett spel som slumpmässigt genererar tre siffror från 1 till 20. Användaren tar fem varv gissar siffrorna. När användaren lämnar ett korrekt giss, gratulerar programmet användaren. ("Bra gissning", säger programmet.) När användaren lämnar ett felaktigt gissning ger programmet ingen återkoppling.

Listning 3 innehåller någon kod för att få allt att hända.

Listing 3

importera statisk java. lang. Systemet. ut; importera java. util. Scanner; importera java. util. Slumpmässig; offentlig klass GuessAgainAndAgain {public static void main (String args []) {Skanner tangentbord = ny skanner (System. in); int inputNumber; int randNum1 = nytt slumpmässigt (). nextInt (20) + 1; int randNum2 = nytt slumpmässigt (). nextInt (20) + 1; int randNum3 = nytt slumpmässigt (). nextInt (20) + 1; ut. println ("************"); ut. println ("Välkommen till gissningsspelet"); ut. println ("************"); ut. println (); för (int i = 0; i <5; i ++) {out. skriv ut ("Ange en int:"); inputNumber = tangentbord. nextInt (); om (inputNumber! = RandNum1 && inputNumber! = RandNum2 && inputNumber! = RandNum3) { fortsätt; } ut. println ("bra gissning!"); ut. println ();} ut. skriv ut ("siffrorna är"); ut. skriv ut (randNum1 + ""); ut. skriva ut (randNum2 + ""); ut. skriv ut (randNum3 + ""); tangentbord. close ();}}

Denna figur visar en körning av ett sådant program.

Java: s fortsatta uttalande berättar att datorn hoppa över de återstående uttalandena i slingan.Det är istället för att exekvera de återstående uttalandena i slingan, datorn går vidare till början av nästa iteration av slingan. Så, i Listing 3, när inputNumber inte är något av programmets slumpmässigt genererade tal hoppar datorn över "Good Guess" -koden, ökar slingräknaren (variabeln i) och frågar användaren om ett annat ingångsvärde. (Om loopbandräknaren träffar sin gräns, utförs datorn inte en annan iteration. Istället springar datorn ut ur slingan och exekverar de uttalanden som följer efter slingan.)

Du kan enkelt skriva om omskrivning Listning 3 så att koden inte har några fortsatta uttalanden. Du måste sätta "God gissning" -koden i ett if-uttalande, men det skulle vara okej. Fortsätt uttalandet gör inte mycket för att förbättra utseendet på Listing 3-programmet. Men när du vill undvika att nesta kod inuti om uttalanden, fortsätter uttalandet är till nytta.

Kanske, i din ansökan är resten av slingan en komplicerad sekvens av uttalanden. Du vill inte göra denna sekvens verkar mer komplicerad genom att omsluta den i en if-förklaring. Eller kanske, i din app, sjunker du bara sällan resten av slingan, och du vill betona denna sällsynthet genom att inte omsluta resten av slingan i ett if-uttalande. I båda fallen kan ett fortsatt uttalande vara exakt det rätta valet.