În acest tutorial, vom învăța cum să reexecutăm părți ale codului nostru într-un mod controlat, analizând diferitele tipuri de bucle din Java... Să aruncăm o privire mai atentă la bucle: in timp ce, do-in timp ce, pentru... Vom încerca să stabilim în ce cazuri, care dintre cicluri este cel mai potrivit pentru utilizare.
Apoi vom arunca o privire rapidă la subiectul numerelor aleatorii ( Aleatoriunumerele). Să ne uităm la Java-Clasă Aleatoriuși cum ne poate ajuta în jocul nostru.
O buclă, după cum sugerează și numele, este o modalitate de a executa aceeași bucată de cod de câte ori este necesar (în timp ce rezultatul executării codului într-o buclă nu va fi neapărat repetat). Numărul de repetări ale execuției buclei poate fi fie definit în avans, fie necunoscut programatorului însuși. Ne vom uita la principalele tipuri de bucle pe care limbajul ne sugerează să le folosim. Java.Și apoi vom introduce unele dintre ele în jocul nostru, îmbunătățindu-l astfel.
While Loop
Ciclu in timp ce are cea mai simplă sintaxă. Tine minte dacă-instrucțiune pe care am studiat-o puțin mai devreme. La expresia condiționată a operatorului dacă(ce este în paranteză după cuvânt dacă) puteți pune aproape orice combinație de operatori și variabile. Dacă expresia este adevărată ( Adevărat), apoi codul inclus în corpul blocului dacă va fi executat. În mod similar, într-o buclă in timp ce punem o expresie care poate evalua la Adevărat sau fals așa cum se arată în acest cod:
Int x = 10; în timp ce (x> 0) (x--; // x scade cu una la fiecare trecere a buclei)
Ce se petrece aici? Primul lucru în afara buclei in timp ce am declarat o variabilă X tip intși a atribuit valoarea „10” acestei variabile. Apoi începe ciclul in timp ce, în starea în care este scris “ x> 0 "- asta înseamnă că codul scris în corpul buclei in timp ce se va executa atâta timp cât variabila X Mai mult 0 iar condiția nu va atinge valoarea fals... Prin urmare, codul va fi executat de 10 ori (x = 10, x> 0; x = 9, x> 0; x = 8, x> 0; x = 7, x> 0; x = 6, x> 0; x = 5, x> 0; x = 4, x> 0; x = 3, x> 0; x = 2, x> 0; x = 1, x> 0). În prima trecere a buclei x = 10, în al doilea deja 9 , în al treilea 8 etc. Și atunci când X va fi egal 0 , atunci condiția de intrare în buclă nu va fi îndeplinită, iar programul va continua din linia următoare după terminarea buclei.
Exact ca la operator dacă, este posibilă o situație în care ciclul să nu fie executat nici măcar o dată. Aruncă o privire la următorul exemplu:
Int x = 10; în timp ce (x> 10) (// ceva cod // dar nu va fi executat niciodată până când x este mai mare de 10)
În plus, nu există restricții privind complexitatea expresiei condiției sau cantitatea de cod care poate fi scris în corpul buclei:
Int playerLives = 3; int alienShips = 10; în timp ce (playerLives> 0 && alienShips> 0) (// Tot codul jocului este aici // ... // ... // etc.) // programul va continua aici când playerLives sau alienShips = 0
Această buclă va rula până la oricare dintre variabile playerLives sau nave străine nu va fi egal sau mai mic de zero. De îndată ce una dintre aceste condiții este îndeplinită, expresia din condiție va lua valoarea fals iar programul va continua pe linia următoare după ce bucla se termină.
Trebuie remarcat faptul că, de îndată ce programul intră în corpul buclei, acesta va fi executat chiar dacă condiția buclei devine fals, undeva în corpul ciclului, pentru că starea se verifică doar la intrare:
Int x = 1; în timp ce (x> 0) (x--; // x este acum 0 și condiția va fi falsă data viitoare // Dar această linie va fi executată // Și aceasta // Și chiar și aceasta)
În exemplul de mai sus, corpul buclei va fi executat o dată. În plus, puteți seta o astfel de condiție încât bucla să ruleze pentru totdeauna - aceasta se numește ciclu nesfârșit. Iată un exemplu:
Int x = 0; în timp ce (adevărat) (x ++; // O să devin foarte mare!)
Ieși din ciclul lor. Cuvânt cheie pauză
Ce se întâmplă dacă într-adevăr trebuie să folosim o buclă infinită, dar astfel încât să putem decide în ce moment să ieșim din ea. În acest scop în Java există un cuvânt cheie pauză... Putem folosi pauză când trebuie să „ieșim” din buclă:
Int x = 0; în timp ce (adevărat) (x ++; // O să devin foarte mare! pauză; // Nu, nu vei! // codul de aici nu va fi atins)
Probabil ați ghicit deja că este posibil să combinați diferite instrumente de luare a deciziilor, cum ar fi dacă,altfel,intrerupatorîn bucla noastră in timp ceși alte bucle, pe care le vom analiza mai jos. De exemplu:
Int x = 0; int preaBig = 10; în timp ce (adevărat) (x ++; // Voi deveni foarte mare! if (x == preaBig) (pauză; // Nu, nu o vei face.) // Codul va fi disponibil aici până când x este 10)
Puteți scrie mai multe variații diferite, dar aplicarea practică a acestor cunoștințe este mai importantă pentru noi, așa că nu vom intra în profunzime acum. Să ne uităm la un alt concept care poate fi operat în buclă.
Cuvânt cheie continua
continua acționează aproape la fel ca pauză... Cuvânt cheie continua vă va da afară din corpul buclei, dar apoi verificați expresia condiționată în loc să continuați după acolada de închidere a buclei, așa cum ar fi cazul cu pauză... Următorul exemplu demonstrează utilizarea lui continua:
Int x = 0; int preaBig = 10; int tooBigToPrint = 5; while (true) (x ++; // Voi deveni foarte mare! if (x == tooBig) (break;) // Nu, nu o vei face. // Codul de aici va fi disponibil doar până când x este 10 if (x> = tooBigToPrint) (// nu va mai fi tipărit pe ecran, dar bucla va continua;) // codul de aici va fi disponibil până când x este egal cu 5 // cod pentru a imprima x pe ecran)
Explicație: declarăm și inițializam variabile. Intrăm în buclă - adăugăm la valoarea variabilei X unitate (acum X= 1). Bifând „1 este 10?” - fals- primul operator dacă neexecutat. Următoarea verificare este „Este 1 mai mare sau egal cu 5?” - fals- al doilea operator dacă neexecutat. Deducem X pe ecran.
Luați în considerare opțiunea când X va lua valoarea 5 la intrarea în buclă. Intrăm în buclă - adăugăm la valoarea variabilei X unitate (acum X= 6). Bifând „6 este 10?” - fals- primul operator dacă neexecutat. Următoarea verificare este „Este 6 mai mare decât sau egal cu 5?” - Adevărat- intrăm în corp dacă — continua, ieșiți din buclă și verificați condiția de intrare în buclă.
Acum opțiunea este când X va lua valoarea 9 la intrarea în buclă. Intrăm în buclă - adăugăm la valoarea variabilei X unitate (acum X= 10). Bifând „10 este egal cu 10?” - Adevărat- intrăm în corp dacă — pauză, ieșiți din buclă și codul va continua în spatele bretei de închidere a buclei in timp ce.
bucla do-while
Aproape la fel ca bucla anterioară, cu excepția unei particularități - verificarea execuției expresiei condiționate va avea loc după corpul buclei. Aceasta înseamnă că ciclul do-in timp ce va rula întotdeauna cel puțin o dată. Aruncă o privire la un exemplu:
Int x = 0; face (x ++;) în timp ce (x< 10); //x теперь = 10
Cuvinte cheie pauză,continua
Pentru buclă
Ciclu pentru are o sintaxă mai complexă decât in timp ceși do-in timp ce deoarece este nevoie de puțin mai multă manipulare pentru a-l inițializa. Să ne uităm mai întâi la el și apoi să îl descompunem în părți:
Pentru (int i = 0; i< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }
Cum îl vede compilatorul? Ca aceasta:
For (declarare și inițializare; condiție; modificare după fiecare buclă) (// corpul buclei)
- Declaratie si initializare- am creat o nouă variabilă de tip int Cu nume iși i-a atribuit valoarea 0 ;
- Condiție- asemanator altor bucle considerate mai devreme, aici verificam conditia de intrare in bucla. Dacă valoarea este calculată ca Adevărat, apoi intrăm în corpul ciclului;
- Schimbare după fiecare ciclu- în exemplul de mai sus i++ înseamnă că după următoarea trecere a buclei suntem la valoarea variabilei i adăugați unul (1). Mai mult, în schimbarea variabilei, putem scrie și i— pentru a scădea unul, de exemplu:
Cuvinte cheie pauză,continua poate fi folosit și în această buclă.
Ciclu pentru preia controlul asupra inițializării, verificării stării și modificării variabilelor. Să încercăm acest ciclu în practică în aplicația noastră imediat după ce ne familiarizăm cu numere aleatoriiși metode.
Te-ai întrebat vreodată de ce există programe? Dacă simplificăm și generalizăm răspunsul la această întrebare, se dovedește că programele sunt necesare pentru a automatiza fluxul de lucru, a crește viteza muncii efectuate, a scăpa o persoană de mii de acțiuni monotone și așa mai departe. Să ne concentrăm pe repetarea acțiunilor una după alta sau, în termeni simpli, a ciclurilor.
O buclă este execuția secvențială a acțiunilor repetitive bazate pe o precondiție dată. De exemplu, trebuie să rearanjați o sută de cutii dintr-un colț în altul. Dacă îl notezi cumva în limbajul Java (din păcate, Java nu poate rearanja casetele pentru tine), atunci primești o sută de rânduri:
1. luați cutia numărul 1 și puneți-o într-un alt colț;
2. luați cutia numărul 2 și puneți-o într-un alt colț;
3. luați cutia numărul 3 și puneți-o într-un alt colț;
…
100. luați cutia #100 și puneți-o în alt colț;
O sută de linii de cod sunt deja multe, dar sunt o mie, două, trei și așa mai departe. În aceste scopuri, și anume, pentru a simplifica înregistrarea acțiunilor repetitive, se folosesc cicluri.
Există trei instrucțiuni care reprezintă bucle în limbajul Java - while, do / white și for. Fiecare dintre operatori este necesar în situația sa, dar operatorul for este încă folosit cel mai des. Să luăm în considerare fiecare dintre operatori în ordine.
În timp ce declarația
Sintaxa pentru instrucțiunea while este următoarea:
În timp ce (condiție) (// acțiuni)
Are loc și îndeplinirea unei anumite precondiții, dar spre deosebire de operatorul if/else, această construcție este construită pe bucle de verificare a stării. Când programul ajunge la instrucțiunea while, dacă condiția propusă este adevărată, toate acțiunile din blocul de acolade (...) sunt executate. După finalizarea acestor acțiuni, programul face din nou o verificare a condiției după instrucțiunea while, iar dacă condiția este din nou adevărată, acțiunile din bloc sunt repetate. Acțiunile din bloc sunt executate până când condiția devine falsă și numai atunci se iese bucla while.
Pentru a ieși din bucle, cel mai des sunt folosite așa-numitele contoare. Luați în considerare un mic exemplu:
Int i = 0; in timp ce eu< 10) { // действия i++; }
Mai întâi, variabilei i i se atribuie valoarea 0, apoi se verifică condiția i0)
(// acțiuni i--;)
Aceleași acțiuni, dar în direcția opusă. În plus, în bucla while (și într-adevăr în alte bucle) este posibil să se utilizeze variabile booleene care conțin valori false sau adevărate. În acest caz, se verifică o anumită condiție prealabilă.
Boolean i = adevărat; în timp ce (i) (// acțiuni)
Variabilei i este adevărată, i se atribuie valoarea true, deci bucla while este executată până când variabilei i i se atribuie valoarea false. Prin urmare, trebuie să aveți grijă să părăsiți o astfel de buclă, altfel bucla while va rula pe termen nelimitat și astfel de bucle se numesc bucle infinite.
În cele din urmă, aș dori să vă atrag atenția asupra operatorului egal ==. Dacă scrieți bucla așa:
Int i = 0 în timp ce (i == 5) (// acțiuni i ++;)
Aceasta se va dovedi a fi o buclă complet funcțională, dar dacă greșiți sau din obișnuință folosiți versiunea clasică a operatorului egal cu =, folosit în matematică, atunci veți avea o problemă sub forma unei bucle infinite.
Int i = 0 în timp ce (i = 5) (// acțiuni i ++;)
În precondiție, variabilei i i se atribuie valoarea 5, dar această acțiune nu este interzisă și cu ce ajungem? Execuția acestui bloc al buclei va începe la sfârșitul căruia valoarea lui i va crește cu unu, dar în precondiția după instrucțiunea while, variabilei i i se va atribui din nou valoarea cinci și bucla își va continua lucrul. pe termen nelimitat. Acesta este un exemplu de buclă infinită simplă și, în consecință, o greșeală clasică care se întâmplă foarte des cu programatorii începători.
Do / while bucla
Bucla while doar considerată de noi, în anumite condiții, poate să nu funcționeze. De exemplu, dacă condiția este inițial falsă, atunci bucla nu va fi niciodată executată. Programul, când ajunge la linia de cod cu instrucțiunea while, va verifica condiția și dacă este falsă, va ignora întreaga buclă și va merge la codul imediat după bucla while. Dar uneori devine necesar să rulați bucla cel puțin o dată. În aceste scopuri, Java are o buclă do/while. Bucla do / while este scrisă și creată după cum urmează:
Efectuați (// acțiuni) în timp ce (condiție)
Există un corp de buclă între instrucțiunile do și while, care va fi executat până când postcondiția care urmează instrucțiunii while este falsă. Corpul buclei va fi executat cel puțin o dată, după care se va verifica condiția. Bucla do / while nu este folosită des, dar uneori se dovedește a fi indispensabilă.
Pentru buclă
Aceasta este cea mai comună buclă în programare. Bucla for se bazează pe manipularea contorului. Semnificația acestei bucle este similară cu buclele while și do / while discutate mai sus. Vedeți cum arată sintaxa pentru o buclă for:
Pentru (int i = 0; i< 10; i++) { // действие }
Cuvântul cheie for este urmat de o condiție pentru executarea buclei. Condiția în sine combină trei etape. Urmează mai întâi inițializarea contorului i = 0, apoi verificarea condiției i< 10 и в конце увеличение переменной i на единицу.
Bucla for funcționează după cum urmează. Când programul ajunge în buclă, atunci contorul i = 0 este inițializat și se verifică condiția i< 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.
În Java, ca în aproape orice limbaj de programare, există instrumente pentru a furniza repetarea multiplă a unei anumite bucăți de cod sau, așa cum sunt numite, bucle. Buclele în Java sunt reprezentate de instrucțiuni precum for și while și variantele acestora. De regulă, buclele sunt folosite pentru a repeta peste matrice unidimensionale și multidimensionale și structuri de date iterabile (inclusiv colecții) pentru a găsi elemente specifice și operațiuni ulterioare cu acestea. Cu toate acestea, aceasta nu este singura modalitate de a utiliza un instrument precum Java Loop. Cazurile de utilizare vor fi furnizate pe măsură ce sunt luate în considerare.
Java: descriere și exemple
Operatorul de buclă fundamental în Java este while. Fragmentul de cod inclus în corpul său se va repeta atâta timp cât condiția expresiei cuprinse între paranteze după ce satisface valoarea logică a adevărului. Forma generală a declarației while este următoarea:
în timp ce (condiție) (
// corpul ciclului
De îndată ce valoarea condiției logice încetează să fie adevărată, codul inclus în corpul buclei se va opri din executare și controlul va fi transferat pe linia imediat următoare.
Dacă există un singur operator în corpul buclei, atunci bretele pot fi omise, dar este considerată o formă bună dacă apar întotdeauna. Figura de mai sus prezintă o diagramă bloc a funcționării acestui operator.
Pentru claritate, să aruncăm o privire la exemplul prezentat în figura de mai jos:
Numărul de variabile declarate are inițial valoarea 1. În continuare, vedem o expresie booleană cuprinsă în paranteze după numele operatorului. Va fi adevărat, adică returnează adevărat atâta timp cât valoarea variabilei de numărare este mai mică sau egală cu 10. În corpul buclei, cu fiecare trecere (iterație), valoarea variabilei este mărită cu 1 și afișată pe ecranul consolei. Rețineți că atunci când variabila a ajuns la 11, bucla a încetat să ruleze.
Dacă valoarea variabilei a fost inițial egală cu 11, atunci condiția buclei ar fi falsă, iar programul nici măcar nu ar intra în corpul său.
Este demn de remarcat faptul că sintaxa Java vă permite să utilizați o declarație while fără un corp. Să dăm un exemplu. Să presupunem că avem două variabile i = 100 și j = 200, ne confruntăm cu sarcina de a calcula media lor aritmetică în mod programatic - pentru aceasta puteți folosi „hollow” în timp ce:
în timp ce (++ i< --j);
Ca rezultat, valoarea oricăreia dintre cele două variabile va fi egală cu media valorilor lor originale. După cum puteți vedea, bucla a funcționat bine fără corp și a efectuat toate acțiunile necesare într-o expresie condiționată.
bucla do-while
În exemplele anterioare, dacă expresia condiționată a returnat inițial fals, atunci execuția programului ar ignora corpul buclei și va continua. Totuși, adesea apar situații în care execuția codului conținut în corpul buclei este obligatorie cel puțin o dată, indiferent de adevărul expresiei condiționate. Cu alte cuvinte, se întâmplă că se cere să se verifice adevărul unei expresii condiționale nu la început, ci la sfârșitul ciclului. O variație a buclei while numită do-while poate oferi această funcționalitate. Are următoarea formă:
face (
// corpul ciclului
) în timp ce (condiție);
După cum putem vedea, mai întâi corpul buclei trece la execuție și abia apoi se verifică adevărul condiției - și așa mai departe la fiecare iterație.
Codul de mai sus va funcționa în același mod ca și cu un timp obișnuit. Cu toate acestea, dacă am fi atribuit valoarea 11 numărului de variabile, corpul buclei ar fi încă executat o dată înainte ca operatorul să poată testa expresia ca fiind adevărată.
Descriere și exemple pentru - bucla Java
Este o formă de limbaj versatilă și eficientă în Java. Înainte de cea de-a cincea versiune a SDK-ului Java, exista o singură formă tradițională a declarației for, apoi a apărut una nouă - pentru fiecare. În această secțiune, ne vom familiariza cu forma tradițională a operatorului. pentru Java, bucla arată astfel:
Înainte ca controlul să fie transferat în codul din corpul buclei, variabila i este inițializată pentru a acționa ca un numărător. În continuare, se verifică o expresie condiționată, în care contorul este comparat cu o anumită valoare, iar dacă returnează adevărat, se execută corpul buclei. Apoi valoarea contorului este schimbată printr-un pas predeterminat și expresia condiționată este verificată din nou și așa mai departe până când condiția devine falsă. Diagrama de mai jos ilustrează toate etapele ciclului.
Pentru o mai bună înțelegere, iată un exemplu despre cum funcționează bucla for Java:
Putem vedea că variabila loopVal este folosită ca numărător. După fiecare iterație a buclei, valoarea acesteia va crește cu 1, iar aceasta va continua până când ajunge la 11. Rețineți că variabila de control poate fi declarată în afara instrucțiunii for, dar dacă nu veți folosi această variabilă oriunde decât într-o buclă, este recomandat să o declarați direct în declarație. Rețineți că o variabilă declarată în declarația în sine este acoperită în cadrul acelei bucle.
Există situații în care trebuie să declarați mai multe variabile care controlează bucla. Pentru Java, o buclă vă permite să specificați două sau mai multe variabile separate prin virgule, iar acest lucru se poate face atât în timpul inițializării, cât și în timpul iterației. Un astfel de operator va arăta astfel:
pentru (int i = 1, int j = 10; i< j; ++i, --j) {}
Cu fiecare iterație, valoarea variabilei i va crește cu 1, iar valoarea variabilei j va scădea cu 1. Iterațiile vor fi efectuate până când i este mai mare sau egal cu j.
Specificații privind utilizarea operatorului for
Bucla for este destul de flexibilă, deoarece toate cele trei părți ale acesteia (inițializare, condiție și creștere/decrementare) pot fi utilizate în afara etichetei. De exemplu, în loc de o expresie condiționată cu o variabilă de control, puteți înlocui orice variabilă booleană.
boolean exit = fals;
pentru (int i = 0;! ieșire; ++ i) (
În exemplul de mai sus, putem observa cum munca buclei este absolut independentă de variabila de control i și numărul de iterații depinde numai de momentul în care variabila ieșire devine adevărată. Mai mult, variabila de control poate fi eliminată complet din buclă și acest lucru nu va afecta în niciun fel funcționarea acesteia: for (;! Exit;) (). Deși nu este cel mai inteligent mod de a programa, poate fi util uneori. Principalul lucru este să prevăd o situație în care variabila va lua valoarea necesară ieșirii din buclă, pentru a nu o transforma într-una infinită.
Pentru Java, o buclă poate fi declarată în acest fel: for (;;) (). Acesta este un exemplu tipic de buclă infinită cu condiții speciale de întrerupere. Vom vorbi despre cum să întrerupem astfel de cicluri puțin mai târziu.
Pentru fiecare buclă
Bucla Java foreach este întotdeauna folosită pentru a itera elementele unei matrice sau ceva și pentru a efectua anumite operații repetitive asupra acestora. Un exemplu de această formă a declarației for este prezentat mai jos:
Name este declarat ca o variabilă de iterație, iar matricea names de șiruri declarată mai devreme este al doilea argument al operatorului. Numele variabilei va lua pe rând valorile fiecărui element al matricei până când toate elementele sale vor fi preluate. Trebuie remarcat faptul că tipul variabilei trebuie să fie compatibil cu tipul elementelor care sunt stocate în matrice. De asemenea, variabila nume este disponibilă exclusiv pentru citire și o încercare de a o schimba nu va schimba elementul în sine din matrice.
Operatori de întrerupere a buclei
Există trei instrucțiuni de întrerupere a buclei: break, return și continue. Primele două sunt capabile să întrerupă complet activitatea buclei, în timp ce Continu întrerupe doar activitatea iterației curente. Dacă utilizați în mod deliberat o buclă Java infinită în codul dvs., acești operatori trebuie să fie prezenți în el. Să ne uităm la un exemplu simplu de utilizare a pauzei:
Deși această instrucțiune for oferă 11 iterații, vor fi executate doar 8, deoarece atunci când contorul i este 7, va fi declanșată condiția, în corpul căreia există o instrucțiune break.
Instrucțiunea return funcționează într-un mod similar, cu diferența că nu numai că iese din bucla Java, dar iese și din metoda în care este plasată bucla.
Folosind break-ul ca goto
Trebuie avut în vedere faptul că întreruperea întrerupe activitatea numai buclei în corpul căreia se află direct, adică. dacă îl utilizați într-o buclă imbricată, atunci bucla exterioară nu se va opri din rulare. Pentru aceasta, declarația break poate fi folosită ca o formă civilizată de goto.
În această versiune, acest operator este utilizat împreună cu o etichetă, care vă permite să organizați o ieșire nu numai din bucle, ci și din orice bloc de cod. O etichetă este un identificator numit corespunzător, urmat de două puncte. Eticheta este declarată la începutul blocului de cod pentru a fi marcat. Pentru a întrerupe execuția unui bloc marcat, trebuie să declarați în locul potrivit: break tag_name. Luați în considerare exemplul din figura de mai jos:
Codul declară trei blocuri cu nume de etichetă Unu, Doi și, respectiv, Trei. Declarația break etichetată Two este imbricată în toate cele trei blocuri, dar când este declanșată, programul va ieși din blocurile Trei și Două și va continua execuția în blocul One. Acestea. vom vedea două mesaje în consolă: Trei și Unu.
Concluzie
Ne-am familiarizat cu conceptul de bucle în Java, principalele instrucțiuni while și for, precum și do-while și, respectiv, pentru fiecare formă. Pentru o mai bună înțelegere, vă recomandăm să faceți exerciții folosind acești operatori sub diverse forme, precum și diverse modalități de a le întrerupe și de a trece de la un bloc la altul.
Ultima actualizare: 31.10.2018
Buclele sunt un alt tip de structură de control. Buclele permit, în funcție de anumite condiții, efectuarea unei anumite acțiuni de mai multe ori. Limbajul Java are următoarele tipuri de bucle:
Pentru buclă
O buclă for are următoarea definiție formală:
Pentru ([inițializarea contorului]; [condiția]; [modificarea contorului]) (// acțiuni)
Luați în considerare un standard pentru buclă:
Pentru (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
Prima parte a declarației buclei - int i = 1 creează și inițializează contorul i. Contorul nu trebuie să fie de tip int. Poate fi orice alt tip numeric, de exemplu, float. Înainte ca bucla să fie executată, contorul va fi 1. În acest caz, aceasta este la fel cu declararea unei variabile.
A doua parte este condiția în care va fi executată bucla. În acest caz, bucla va rula până când i ajunge la 9.
Și a treia parte este creșterea contorului cu unul. Din nou, nu trebuie să creștem cu unul. Poate fi redus: i--.
Ca rezultat, blocul buclei va rula de 8 ori până când valoarea lui i devine egală cu 9. Și de fiecare dată această valoare va crește cu 1.
Nu trebuie să specificăm toate condițiile atunci când declarăm o buclă. De exemplu, putem scrie astfel:
Int i = 1; pentru (;;) (System.out.printf ("Pătratul% d este% d \ n", i, i * i);)
Definiția buclei rămâne aceeași, doar că acum blocurile din definiție sunt goale: for (;;). Acum nu există nicio variabilă de contor inițializată, nicio condiție, așa că bucla va rula pentru totdeauna - o buclă infinită.
Alternativ, puteți omite un număr de blocuri:
Int i = 1; pentru (; i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }
Acest exemplu este echivalent cu primul exemplu: avem și un contor, doar că a fost creat în afara buclei. Avem o condiție pentru execuția buclei. Și există deja o creștere a contorului în blocul for în sine.
Bucla for poate defini și manipula mai multe variabile simultan:
Int n = 10; pentru (int i = 0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }
Faceți bucla
Bucla do execută mai întâi codul buclei și apoi verifică condiția din instrucțiunea while. Și atâta timp cât această condiție este adevărată, ciclul se repetă. De exemplu:
Int j = 7; do (System.out.println (j); j--;) while (j> 0);
În acest caz, codul buclei va rula de 7 ori până când j este egal cu zero. Este important de reținut că bucla do garantează cel puțin o execuție a acțiunii, chiar dacă condiția din instrucțiunea while nu este adevărată. Deci, putem scrie:
Int j = -1; do (System.out.println (j); j--;) while (j> 0);
Deși j este inițial mai mic decât 0, bucla se va executa totuși o dată.
buclă în timp ce
Bucla while verifică imediat adevărul unei anumite condiții, iar dacă condiția este adevărată, atunci codul buclei este executat:
Int j = 6; în timp ce (j> 0) (System.out.println (j); j--;)
Declarațiile continue și break
Instrucțiunea break vă permite să părăsiți bucla în orice moment, chiar dacă bucla nu și-a încheiat activitatea:
De exemplu:
< nums.length; i++){ if (nums[i] >10) pauză; System.out.println (numerele [i]); )
Deoarece bucla verifică dacă elementul de matrice este mai mare de 10, nu vom vedea ultimele două elemente pe consolă, deoarece atunci când nums [i] este mai mare de 10 (adică egal cu 12), va fi declanșată instrucțiunea break. iar bucla se va termina.
Adevărat, nu vom vedea nici ultimul element, care este mai mic de 10. Acum vom face astfel încât, dacă numărul este mai mare de 10, ciclul nu se încheie, ci pur și simplu trece la următorul element. Pentru a face acest lucru, utilizați operatorul de continuare:
Int nums = new int (1, 2, 3, 4, 12, 9); pentru (int i = 0; i< nums.length; i++){ if (nums[i] >10) continua; System.out.println (numerele [i]); )
În acest caz, când execuția buclei ajunge la numărul 12, care nu satisface condiția de testare, programul va sări peste acest număr și va trece la următorul element al matricei.
O buclă este un bloc de instrucțiuni care este executat din nou și din nou atâta timp cât este îndeplinită o anumită condiție. Piesa repetată de cod se numește „corpul buclei”. O execuție a unui corp de buclă se numește iterație.
În Java, puteți lucra cu bucle de mai multe tipuri - pentru aceasta există următorii operatori:
in timp ce- ciclu cu condiție prealabilă- mai intai verificam starea, apoi executam corpul ciclului;
face în timp ce- ciclu cu postcondiție- mai intai executam corpul ciclului o data, apoi verificam starea si, daca este indeplinita, continuam;
pentru- o buclă cu numărător - se execută și la fiecare iterație actualizează contorul atâta timp cât condiția din declarația buclei este îndeplinită (adică verificarea condiției revine adevărată);
stenografie pentru(cunoscut ca foreach în alte limbi) - iterează peste matrice de la primul element până la ultimul și execută corpul buclei la fiecare iterație.
Esența condiției buclei este verificarea unei expresii cu una sau mai multe variabile: „În timp ce a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?
Dacă folosim constructe while, valoarea trebuie specificată înainte de începerea buclei:
int a = 1;
In timp ce< 11) {
System.out.println (a);
a ++; // crește a cu unu
}
Dacă o variabilă funcționează ca un numărător de bucle și nu este utilizată în afara acesteia, este inițializată direct în condiție. Și apoi scriu ce să facă cu el la sfârșitul fiecărei iterații. Toate acestea într-o singură linie - folosind pentru:
pentru (a = 1, a<11, i++) {
System.out.println (a);
}
Obținem același rezultat. Lista ar putea fi începută de la zero sau de la o valoare negativă - definim singuri intervalul.
Scurtarea pentru buclă nu indică numărul de repetări sau acțiunile de la sfârșitul unui pas. O buclă foreach este folosită pentru a itera peste matrice. De la primul element trebuie să treceți la următorul - până când matricea se termină.
int ms = (1, 2, 3, 4); // creează o matrice
int s = 0;
pentru (int i: ms) (// indică pe ce să iterați
s * = i; // înmulțim secvențial elementele
}
System.out.println (e);
bucle imbricate Java
Ciclurile pot fi imbricate unul în celălalt. În acest caz, numărul de repetări ale buclelor exterioare și imbricate este înmulțit. Dacă exteriorul urmează să fie executat de 5 ori și interiorul trebuie să fie executat de 5 ori, întreaga buclă va fi executată de 25 de ori.
Să afișăm tabelul înmulțirii folosind două matrice:
int a, b, rezultat = 0;
pentru (a = 2; a< 10; a++) {
pentru (b = 2; b< 10; b++) {
rezultat = a * b;
System.out.println (a + "x" + b + "=" + rezultat);
}
}
Crearea de obiecte într-o buclă Java
Buclele sunt utile atunci când trebuie să creați și să numerotați multe obiecte. Numărul lor este uneori necunoscut dinainte: obiectele pot fi create la cererea utilizatorului. Așa că am întrebat cât de mult este nevoie de ceva și am scris numărul în variabila n. Acum să creăm obiecte în cantitatea necesară:
Ceva matrice = nou Ceva [n]; // creează o matrice de tip „ceva” din n elemente
pentru (int i = 0; i< n; i++){
matrice [i] = ceva nou (); // creează „ceva” și pune-l într-o matrice
}
Cum să ieși dintr-o buclă Java
Pentru a ieși din buclă, există cuvintele cheie pauză - „întrerupere”, continuare - „reluare” și întoarcere - „întoarcere”. Comanda break comută programul pentru a executa instrucțiunile care urmează buclei. Condițiile de întrerupere a buclei în Java sunt formalizate prin ramificare if. Principalul lucru este că verificarea este efectuată înaintea corpului principal al buclei.
// după crearea matricei m, scrieți:
pentru (a: m) (
dacă (a == 5) rupe;
System.out.println (a);
}
Operatorii de ramificare și buclă din Java lucrează adesea împreună: începem o buclă, iar în interiorul ei verificăm dacă este încă îndeplinită o condiție, în care este necesar să întrerupem bucla sau să facem altceva.
Dacă utilizați break într-o buclă imbricată, numai aceasta se va rupe, iar cea exterioară va continua să se execute.
Pentru a întrerupe prematur iterația unei bucle for în Java, utilizați continuare. Când programul ajunge la el, omite partea nefinalizată a iterației, actualizează contorul și trece la următoarea iterație.
În constructele while, același continue funcționează diferit: ne întoarce la verificarea condiției de continuare a buclei. O altă comandă - returnare - returnează programul în locul în care a fost apelată metoda, în care se află bucla.
Atât continuare, cât și break pot fi folosite cu o etichetă - pentru a sări la partea dorită a codului - prin analogie cu goto:
rupe Mark1; // cu condiția să existe un Mark1 undeva mai sus:
buclă infinită Java
Este ușor să creezi o buclă infinită - trebuie doar să omiteți parametrii pentru:
pentru (;;) ()
Cu cât este mai greu să beneficiezi de el. De obicei, o buclă infinită este o eroare fatală care interferează cu execuția programului. Prin urmare, fiecare ciclu ar trebui verificat pentru capacitatea de a se finaliza corect la momentul potrivit. Pentru asta ai nevoie de:
- specificați condițiile de întrerupere în corpul buclei,
- asigurați-vă că variabila în starea de întrerupere poate lua o valoare la care bucla se va opri.
