Diagramă de comparație:
| Bazele comparației | pauză | continua |
|---|---|---|
| Sarcină | Încetează executarea iterației rămase a bucla. | Termină numai iterația curentă a buclei. |
| Control după întrerupere / continuare | "pauză" reia controlul programului până la sfârșitul buclăului care include această "pauză". | "continuă" reia controlul programului la următoarea iterație a acelei bucla care include "continuă". |
| cauze | Aceasta provoacă terminarea anticipată a bucla. | Aceasta provoacă executarea timpurie a următoarei iterații. |
| Continuare | "pauză" oprește continuarea buclei. | "continuă" nu oprește continuarea buclei, ci doar oprește repetarea curentă. |
| Alte utilizări | 'break' poate fi folosit cu 'switch', 'label'. | "continuă" nu poate fi executată cu "switch" și "labels". |
Definiția Break
În ruperea C ++ există doar două utilizări, adică primul este folosit pentru a "termina executarea unui caz în comanda switch". În al doilea rând, să "terminăm bucla și să reluăm comanda la următoarea instrucțiune care urmează buclă". Dar, în Java pauză are mai întâi trei utilizări, se termină cazul în comutator, al doilea pentru a termina buclă închiderea pauză și a treia, după cum sa menționat mai devreme că Java nu oferă o declarație 'goto', dar pauza de formă extinsă poate fi folosită în loc de "goto".
Să vedem, fiecare utilizare a "pauzei" în detaliu.
Prima utilizare pentru a termina executarea casetei în comutator. Întreruperea întrerupătorului afectează numai comutatorul care o înconjoară, nu afectează bucla care închide comutatorul.
// În contextul C ++. // folosind întreruperi în comutator în contextul C ++. comutator (expresie intreg) {caz 1: ..... ..... pauză; cazul 2: ..... ..... pauză; cazul 3: ..... ..... ruperea; Mod implicit: ....... ....... } A doua utilizare, pentru a termina forța buclă și a relua la următoarea afirmație a buclă. Imediat ce declarația de spargere este întâlnită în bucla, acea buclă este terminată imediat fără a executa restul de cod în corpul acelei buclă, iar controlul programului ajunge la următoarea instrucțiune scrisă după acea buclă.
// folosirea pauzei pentru a iesi din buclă în context la clasa Java main_class {public static void principal (string args []) {pentru (int i = 0; i <100; i ++) {system.out.println ("i: + i); if (i == 10) rupe; // deoarece condiția din interiorul "if" setește controlul vine din bucla "pentru". } system.out.println ("Loop breaks here"); }} rupeți doar programul să iasă din bucla care o înconjoară. Dacă pauza este utilizată cu buclă imbricată, aceasta va rupe doar bucla interioară și nu va afecta bucla exterioară.
A treia utilizare, folosind pauza ca forma de goto. Java utilizează pauza ca formă de geto fără probleme. Deoarece geto oferă o ramificație nestructurată, care este greu de înțeles și care interzice și optimizarea compilatorului, Java folosește o formă extinsă de pauză care este similară cu geto și ajută la ieșirea mai multor blocuri la un moment dat și reluarea controlului programului la sfârșitul blocului etichetat, menționat cu instrucțiunea de pauză.
Declaraţie:
eticheta de rupere;
Aici, "label" este numele unui anumit bloc de cod sau un identificator în Java, iar acest bloc etichetat trebuie să cuprindă instrucțiunea de pauză. Instrucțiunea de rupere etichetă este utilizată pentru a ieși din setul de bucăți imbricate. Pe măsură ce se întâlnește instrucțiunea de pauză marcată, comanda iese din blocul etichetat care este menționat cu instrucțiunea de pauză.
Să o vedem practic.
// folosirea pauzei ca formă de goto în context la clasa Java main_class {public static void principal (string args []) {boolean t = true; primul {al doilea {al treilea {system.out.println ("acest al treilea bloc"); dacă (t) se rupe primul; } system.out.println ("acest al doilea bloc"); } system.out.println ("acest prim bloc"); } system.out.println ("acest bloc principal"); }} // ieșire: acesta este al treilea bloc, acesta este blocul principal În acest cod, deoarece controlul ajunge la cel de-al treilea bloc, declarația de tipărire este executată și după aceea comanda revine la instrucțiunea "if" și, deoarece este satisfăcută, se execută instrucțiunea de spargere cu eticheta. Eticheta atașată cu pauză este în primul rând, astfel încât controlul să revină la instrucțiunea scrisă după sfârșitul blocului, adică în blocul principal care este o instrucțiune de tipărire și care este executat.
Definiția Continue
Când pauza termină iterația rămasă a bucla și permite ieșirea din buclele de control, aici continuați lucrările oarecum funcționează ca o pauză. Instrucțiunea continuă oprește execuția codului rămas în bucla pentru acea iterație curentă și reia controlul la următoarea iterație a respectivei bucla. Instrucțiunea continuă trece codul pentru iterația curentă și trece controlul la următoarea iterație a buclă.
Să înțelegem cu un exemplu.
// folosirea continuă în context la C ++. // se tipărește numărul par până la 100. class main_class {public static void principal (string args []) {pentru (int i = 0; i <100; i ++) {if (i% 2! = 0) continuați; // continua reluarea controlului la următoarea iterație în for loop system.out.println ("i:" + i); }}} În programul de mai sus, dacă instrucțiunea "if" este îndeplinită, atunci se execută instrucțiunea continuă, care nu permite ca următoarea instrucțiune de imprimare să execute și să reia controlul la iterația următoare a buclă "for". Dacă i = 1, atunci condiția "if" este îndeplinită și continuă execută, fără a executa instrucțiunea de tipărire pentru valoarea impare a lui "i", iar controlul revine la următoarea iterație a bucla "pentru i = 2". Dacă i = 2 atunci declarația "if" nu este îndeplinită prin urmare; continuă nu execută și imprimă instrucțiunea imprimă valoarea lui "i", care este egal.
Diferențele cheie între pauză și continuă
- Practic, cuvântul cheie break întrerupe restul de iterații ale bucla. Pe de altă parte, cuvântul cheie continuă termină numai iterația curentă a buclă.
- Odată ce execută cuvântul cheie de pauză, controlul programului iese din bucla și reia la următoarea declarație după buclă. În cazul cuvântului cheie continuu, controlul programului revine la următoarea iterație a buclă.
- După cum se concluzionează pasul de mai sus, după executarea controlului de întrerupere a ieșirii din program, se înțelege clar că ruperea provoacă terminarea anticipată a oricărei bucle. Pe de altă parte, continuați să terminați numai iterația curentă și reluați următoarea iterație a buclei, atunci putem spune că continuă determină executarea timpurie a iterației următoare a buclei.
- Cuvântul cheie break întrerupe întreaga iterație rămasă după execuție, astfel încât putem spune că oprește continuarea buclei, în timp ce cuvântul cheie continuă continuă execuția bucla.
- Cuvântul cheie break poate fi utilizat împreună cu instrucțiunile "switch", precum și cu "label", în timp ce cuvântul cheie continuă nu poate fi folosit cu "switch" și "label".
Concluzie:
Declarația de rupere și de continuare sunt ambele instrucțiuni de salt care transferă controlul către o altă parte a programului. În cazul în care declarația de pauză lăsați comanda să iasă din bucle, instrucțiunea continuă permite controlul la următoarea iterație a acelei bucle.
