Innholdsfortegnelse:
Video: #3.3 Java Tutorial | While | For | Iteration Statement | Loops 2024
For å gjøre Java-programmets sløyfer lettere å skrive og lettere å forstå, må du vite hvordan Javas pause og fortsette setninger påvirker loop-iterasjoner.
Java's break statement
Ta en gander på programmet nedenfor. Programmet genererer tilfeldig et tall fra 1 til 10, og gjentatte ganger brukeren å gjette det nummeret.
Liste 1
importer statisk java. Lang. System. ute; importer java. util. Scanner; importer java. util. Tilfeldig; offentlig klasse GuessAgain {offentlig statisk tomt hoved (String args []) {Scanner keyboard = ny skanner (System. in); int numGuesses = 0; int randomNumber = ny tilfeldig (). nextInt (10) + 1; ute. println ("************"); ute. println ("Velkommen til gjettespillet"); ute. println ("************"); ute. println (); ute. skriv ut ("Skriv inn en int fra 1 til 10:"); int inputNumber = tastatur. nextInt (); numGuesses ++; mens (inputNumber! = RandomNumber) { ut. println (); ute. println ("Prøv igjen …"); ute. skriv ut ("Skriv inn en int fra 1 til 10:"); inputNumber = tastatur. nextInt (); numGuesses ++; } ut. skriv ut ("du vinner etter"); ute. println (numGuesses + "guesses."); tastatur. lukk ();}}
Figuren under viser en kjøring av koden. Brukeren gjør fem gjetninger. Hver gang kontrollerer datamaskinen å se om gjetningen er riktig. En feil gjetning genererer en forespørsel om å prøve igjen. For en riktig gjetning får brukeren en rousing Du vinner, sammen med et antall av gjetninger han eller hun gjorde. Datamaskinen gjentar flere setninger om og om igjen, sjekker hver gang for å se om brukerens gjetning er det samme som det tilfeldig genererte nummeret. Hver gang brukeren gjetter en gjetning, legger datamaskinen 1 til sin rekkevidde av gjetninger. Når brukeren gjør riktig gjetning, viser datamaskinen det som teller.
Hva er vanskelig om dette programmet? Vel, noen få erklæringer vises mer enn en gang i programmet. Normalt er en utsagn som er kopiert fra en del av et program til et annet, ingen grunn til bekymring. Men den overordnede strategien virker mistenkelig. Programmet får et nummer fra brukeren før sløyfen og (igjen) inne i sløyfen.
ut. skriv ut ("Skriv inn en int fra 1 til 10:"); int inputNumber = tastatur. nextInt (); numGuesses ++; mens (inputNumber! = RandomNumber) {out. println (); ute. println ("Prøv igjen …"); ut. skriv ut ("Skriv inn en int fra 1 til 10:"); inputNumber = tastatur. nextInt (); numGuesses ++; }
Denne koden bruker et standardtrick for å lage looper. Den kalles priming en loop. Mønsteret er
Få inntasting mens inngangen du har, ikke er den siste inngangen { Få flere innspillinger }
Ved starten av mensløkken, kontrollerer datamaskinen en tilstand som har å gjøre med brukerens inngang. Så går ikke datamaskinen inn i sløyfen til brukeren gir noe innspill. Så når datamaskinen er inne i sløyfen, ber datamaskinen om mer inngang for å mate loopens neste iterasjon. Trikset virker rart, men det virker.
Utviklere bruker denne teknikken, priming en loop, hele tiden, så det kan ikke være så ille. Men det er en annen måte.
Liste 2
importer statisk java. Lang. System. ute; importer java. util. Scanner; importer java. util. Tilfeldig; offentlig klasse GuessAgain {offentlig statisk tomt hoved (String args []) {Scanner keyboard = ny skanner (System. in); int inputNumber, numGuesses = 0; int randomNumber = ny tilfeldig (). nextInt (10) + 1; ute. println ("************"); ute. println ("Velkommen til gjettespillet"); ute. println ("************"); ute. println (); mens (sant) { ut. skriv ut ("Skriv inn en int fra 1 til 10:"); inputNumber = tastatur. nextInt (); numGuesses ++; hvis (inputNumber == randomNumber) { pause; } ut. println (); ute. println ("Prøv igjen …"); } ut. skriv ut ("du vinner etter"); ute. println (numGuesses + "guesses."); tastatur. Lukk ();}}
Fra brukerens synspunkt gjør koden i Liste 2 nøyaktig det samme som koden i Liste 1. (For å se utgangen av et program, se figuren ovenfor.) forskjellen er Oppføring 2 har bare ett anrop til tastaturet. nextInt. Det kallet er inne i løkken, så datamaskinen må gå inn i løkken uten å teste innspill.
Hvis du ser på sløyfenes tilstand, kan du se hvordan dette fungerer. Sløyfen er alltid sant. Uansett hva som foregår, går slingens tilstand alltid sin test. Så sløyfen er en stor svindel. Du hopper aldri ut av løkken ved å feile testen i løpens tilstand. I stedet hopper du ut når du slår break-setningen som er inne i sløyfen (og du treffer den bruddoppstillingen når du kommer forbi hvis (inputNumber == randomNumber) veikryss). Hele greia fungerer veldig bra.
Når datamaskinen utfører en pauseoppgave som er i en loop, hopper datamaskinen ut av sløyfen (til den første setningen som kommer etter sløyfen).
Med en pauseoppgave springer datamaskinen ut av bare en sløyfe. Hvis den sløyfen er i en annen sløyfe (en ytre sløyfe), hopper datamaskinen ikke ut av den ytre sløyfen.
offentlig klasse BreakOutOfLoop {Stats [] args) { for (int i = 0; i <3; i ++) { for (int j = 0; j <100; j ++) { System. ute. skriv ut (j + ""); hvis (j> 9) {break;} } System. ute. println ("jeg brøt ut!"); } }}
For å illustrere inneholder følgende figur utgangen av den forrige koden:
Når datamaskinen når pauseoppsigelsen, hopper kontrollen til jeg slår ut setningen.At jeg brøt utsagnet er utenfor av for-løkken, men det er inne for jeg-sløyfen.
Fra programmørens synspunkt er koden i liste 2 mer naturlig enn koden i liste 1. Tross alt, hvordan går spillet videre? Brukeren gjetter, da kontrollerer datamaskinen gjetningen, og deretter (hvis gjetningen ikke er riktig) sier datamaskinen "Prøv igjen. "Det er sekvensen av hendelser som beskrevet i Oppføring 2. Men i Oppføring 1 ser koden inne i sløyfen å beskrive hendelsene i omvendt rekkefølge: Sløyfen sier" Prøv igjen ", og så legger brukeren inn et nummer.
Liste 2 gir et fint alternativ til loop-priming teknikken i Listing 1. Så hvorfor bryter programmører seg med å prime sine looper? Har pause uttalelser har noen skjulte ulemper? Vel, svaret avhenger av ditt synspunkt. Noen programmerere tror at bruddopplysninger i sløyfer er forvirrende. Alt hopper fra setning til setning gjør dem svimmel og minner dem om noe fra 1960-tallet kalt spaghetti kode . (Spaghetti-koden bruker goto-setninger til å hoppe fra en setning til en annen. I Pascal ved eksempel sier forfatter B. Burd "Programmering med goto er som å reise rundt i Paris ved å svømme gjennom avløpssystemet. korte kutt, men ingen av dem er verdt å ta. ") På en eller annen måte, er brudd på sløyfer unntaket, ikke regelen. Bruk dem hvis du vil, men ikke forvent å finne mange av dem i andres Java-kode.
Java's fortsette setning
Listing 3 tilbyr mer hemmelig saus til programmets looper. Tenk deg et spill som tilfeldigvis genererer tre tall fra 1 til 20. Brukeren tar fem svinger gjetter tallene. Når brukeren går inn i riktig gjetning, gratulerer programmet brukeren. ("God gjetning", sier programmet.) Når brukeren går inn i feil gjetning, gir programmet ingen tilbakemelding.
Liste 3 inneholder noen kode for å få alt til å skje.
Liste 3
importer statisk java. Lang. System. ute; importer java. util. Scanner; importer java. util. Tilfeldig; offentlig klasse GuessAgainAndAgain {offentlig statisk tomrom main (String args []) {Skannertastatur = ny skanner (System. in); int inputNumber; int randNum1 = nytt tilfeldig (). nextInt (20) + 1; int randNum2 = nytt tilfeldig (). nextInt (20) + 1; int randNum3 = nytt tilfeldig (). nextInt (20) + 1; ute. println ("************"); ute. println ("Velkommen til gjettespillet"); ute. println ("************"); ute. println (); for (int i = 0; i <5; i ++) {ut. skriv ut ("Skriv inn en int:"); inputNumber = tastatur. nextInt (); hvis (inputNumber! = RandNum1 && inputNumber! = RandNum2 && inputNumber! = RandNum3) { fortsett; } ut. println ("God gjetning!"); ute. println ();} ut. skriv ut ("Tallene er"); ute. skriv ut (randNum1 + ""); ute. skriv ut (randNum2 + ""); ute. skriv ut (randNum3 + ""); tastatur. lukk ();}}
Denne figuren viser en kjøring av et slikt program.
Java's fortsatte setning forteller at datamaskinen skal hoppe forbi de resterende utsagnene inne i sløyfen.Det er, i stedet for å utføre de resterende utsagnene inne i løkken, beveger datamaskinen seg til starten av den neste iterasjonen av løkken. Så, i oppføringen 3, når inputNumber ikke er noe av programmets tilfeldig genererte tall, hopper datamaskinen forbi "God gjetning" -koden, øker loop-telleren (variablen i), og spør brukeren om en annen inngangsverdi. (Selvfølgelig, hvis loop-telleren treffer grensen, utfører datamaskinen ikke en annen iterasjon. I stedet hopper datamaskinen ut av sløyfen, og utfører hvilke setninger som kommer etter sløyfen.)
Du kan enkelt omskrive Listing 3 slik at koden ikke har noen fortsatte setning. Du må sette "God gjetning" -koden i en if-setning, men det ville være ok. Fortsettelseserklæringen gjør ikke mye for å forbedre utseendet til Listing 3-programmet. Men når du vil unngå å nesting kode inne hvis uttalelser, fortsetter uttalelsen kommer til nytte.
Kanskje, i søknaden din, er resten av løkken en komplisert rekkefølge av uttalelser. Du vil ikke gjøre denne sekvensen mer komplisert ved å legge den inn i en hvis-setning. Eller kanskje i appen din, sjelden du bare hopper over resten av løkken, og du vil understreke denne sjeldenheten ved ikke å omslutte resten av løkken i en if-setning. I begge tilfeller kan en fortsatt uttalelse være akkurat det riktige valget.
