Walang katapusang para sa (Java) cycle

Sa Java, tulad ng sa halos anumang programming language, may mga kasangkapan upang magbigay ng maramihang mga pag-uulit ng isang partikular na piraso ng code, o, bilang sila ay tinatawag na, cycles. Mga Loop sa Java ay kinakatawan ng mga operator, tulad ng para sa at habang, pati na rin ang kanilang mga varieties. Karaniwan, ang mga cycles ay ginagamit para sa pagpasa ng isa-dimensional at multi-dimensional array at iterable data istruktura (kabilang ang mga koleksyon) upang makahanap ng ilang mga item at higit pang mga pagpapatakbo sa mga ito. Gayunpaman, ito ay hindi lamang ang paraan ng paggamit ng isang tool tulad ng ang ikot ng Java. Mga halimbawa ng paggamit ay actuated bilang kanilang konsiderasyon.

Umikot Ang habang ang Java: paglalarawan at mga halimbawa

Ang pangunahing cycle operator sa Java ay sandali. Ang code snippet nakapaloob sa kanyang katawan, na paulit-ulit hanggang ang kondisyon na expression, na nakapaloob sa mga panaklong pagkatapos nito, ay masiyahan ang mga lohikal na halaga TRUE. Ang pangkalahatang anyo ng isang habang na pahayag ay ang mga sumusunod:

habang (kondisyon) {

// loop katawan

}

Sa sandaling ang halaga ng mga lohikal na mga kondisyon itigil upang maging totoo, ang mga bilanggo sa loop katawan code ay magtigil na isinasagawa at kontrol maipapasa kaagad pagkatapos maabot ang linya. Kung ang loop ay nakapaloob lamang ng isang operator, braces maaaring iwanang out, ngunit ito ay itinuturing na mahusay na form, kung ang mga ito sa lahat ng oras. figure sa itaas ay nagpapakita ng daloy diagram ng operasyon ng operator.

Para sa kalinawan, tingnan natin ang isang halimbawa, ipinakita sa tayahin sa ibaba:

Ipinahayag variable count ay paunang naka-set sa 1. Sumunod ay isang lohikal na expression nakapaloob sa panaklong pagkatapos ng pangalan ng operator. Ito ay totoo, iyon ay, bumalik ang halaga ng totoo, hangga't ang halaga ng variable count ay mas mababa sa o katumbas ng 10. Sa loop sa bawat pass (ulit) ang variable na halaga ay incremented ng 1 at ipinapakita sa console screen. Tandaan na kapag ang mga halaga ng variable ay umabot 11, cycle tumigil sa pagtatrabaho.

Kung ang halaga ng count sa una katumbas ng 11, ang mga loop na kondisyon ay hindi totoo, at ang programa ay hindi na kahit wala na sa kanyang katawan.

Ito ay nagkakahalaga ng pagpuna na ang Java na syntax ay nagbibigay-daan sa paggamit ng habang statement na walang isang katawan. Narito ang isang halimbawa. Sabihin nating mayroon kami ng dalawang variable i = 100 at j = 200, tayo ay nahaharap sa mga gawain ng software upang makalkula ang kanilang mga average na - maaari mong gamitin ang "guwang» samantalang:

habang (++ i <- j);

Bilang isang resulta, ang halaga ng alinman sa mga dalawang variable ay magiging katumbas ng average ng kanilang unang halaga. Tulad ng iyong nakikita, ang cycle ay nagtrabaho ganap na walang katawan, at kaniyang dinala ang lahat ng mga kinakailangang aksyon sa conditional expression.

Ang cycle ng do-habang

Sa nakaraang halimbawa, kung ang conditional expression ay sa una ay bumalik false, pagkatapos ay ang programa ay may hindi pinansin ang katawan ng loop at nagpunta sa. Gayunman, madalas na may mga sitwasyon na kung saan ang pagpapatupad ng code na nakapaloob sa katawan ng loop, siguraduhin na hindi bababa sa isang beses, hindi alintana ang katotohanan ng conditional expression. Sa ibang salita, ito ang mangyayari na suriin ang pagiging wasto ng conditional expression ay hindi kinakailangan sa simula at sa dulo ng cycle. Ang paggamit na ito ay maaaring magbigay ng isang uri ng isang habang loop na tinatawag do-habang. Ito ay may mga sumusunod na form:

gawin {
// loop katawan

} Habang (kalagayan);

Tulad ng maaari naming makita, una, para sa pagpapatupad cycle ay ang katawan, at lamang pagkatapos ay naka-check ang kalagayan ay totoo - at sa gayon ang bawat pag-ulit.

Ang code sa itaas, nagagampanan ng humigit-kumulang ang parehong tulad ng sa kaso na may isang maginoo sandali. Subalit, kung kami ay bibigyan ng isang halaga ng count 11, loop katawan pa rin matugunan nang isang beses, bago ang operator ay maaaring i-verify ang katotohanan ng expression.

Paglalarawan at mga halimbawa para sa - Java cycle

Para cycle ay isang maraming nalalaman at mahusay na linguistic form sa Java. Hanggang sa ika-limang bersyon ng Java SDK ay lamang ng isang tradisyunal na form ng para pahayag, at pagkatapos ng isang bagong - para sa bawat isa. Sa seksyong ito, kami ay galugarin ang mga tradisyonal na anyo ng operator. para sa Java loop ay ang mga sumusunod:

Bago control code ay ililipat sa loop unang initializes ang variable i, magsilbi bilang ang counter. Dagdag dito, ang conditional expression ay naka-check, kung saan ang counter ay ihinambing sa isang tiyak na halaga, at kung ito ay nagbabalik totoo, ang katawan ay pinaandar. Pagkatapos, ang bilang ng halaga ay nabago sa pamamagitan ng isang paunang natukoy na hakbang, at muli naka-check conditional expression at iba pa hanggang ang kalagayan ay hindi totoo. Block diagram sa ibaba ay naglalarawan sa lahat ng yugto ng cycle.

Para sa isang mas mahusay na pang-unawa bigyan kami ng isang halimbawa ng kung paano ang ikot para sa Java:

Nakita namin na sa loopVal variable ginagamit bilang isang counter. Pagkatapos ng bawat pag-ulit, ang halaga nito ay lalaki sa pamamagitan ng 1, at ito ay mangyayari hanggang pagkatapos, hanggang umabot sa 11. Tandaan na ang control variable ay maaaring ipinahayag sa labas ng para pahayag, ngunit kung hindi mo nais na gamitin ang mga variable sa kahit saan maliban sa cycle, ito ay marapat na idedeklara ito nang direkta sa statement. Isaisip na ang isang variable na ipinahayag sa pahayag na may isang saklaw sa loob ng parehong cycle.

May mga oras kung kailan mo nais na idedeklara ng maramihang mga loop control variable. Para sa Java loop ay nagbibigay-daan sa iyo upang tukuyin dalawa o higit pang mga variable, na pinaghihiwalay ng mga kuwit, at na gawin ito parehong sa kanilang mga initialization, at sa panahon ng pag-ulit. Ang ganitong mga isang operator ay ang mga sumusunod:

para sa (int i = 1, int j = 10; i

Sa bawat pag-ulit, ang halaga ng variable i ay incremented ng 1 at ang halaga ng variable j ay decremented sa pamamagitan 1. Ang mga iteration ay pinaandar hangga't i ay mas malaki kaysa sa o katumbas ng j.

Mga Tampok ng application para statement

para cycle ay lubos na kakayahang umangkop disenyo, dahil ang lahat ng tatlong mga bahagi (initialization, ang kundisyon, at ang paglakas / pagbabawas) ay hindi maaaring gamitin para sa sinasadyang layunin. Halimbawa, sa halip na ang conditional expression na may control variable ay maaaring palitan ang anumang boolean variable.

boolean exit = false;

para sa (int i = 0 ;! exit; ++ i) {

exit = true;

}

Sa halimbawa sa itaas maaari naming makita kung paano ang trabaho cycle ay ganap na independiyenteng mula sa control variable i at ang bilang ng mga iteration ay ganap na nakasalalay sa kung ano ang oras ng exit variable ay naka-set sa tunay na. Dagdag pa rito ang control variable ay maaaring sama-sama inalis mula sa cycle, at hindi ito makakaapekto sa kanyang trabaho: para sa (; exit ;!) {}. Kahit na ito ay hindi ang pinaka-makatwirang paraan upang programa, maaari itong minsan ay maging kapaki-pakinabang. Ang pangunahing bagay - upang magbigay ng para sa isang sitwasyon kung saan ang mga variable na ay magdadala sa kanan upang lumabas mula sa cycle na halaga, sa gayon ay hindi upang i-on ito sa isang walang katapusang.

Para sa Java cycle ay maaaring inihayag at sa ganitong paraan: para sa (;;) {}. Ito ay isang tipikal na halimbawa ng isang walang-katapusang loop na may mga espesyal na mga kondisyon ng tuluy-tuloy. Tungkol iyon, kung paano gumagana ang ganitong uri ng abala cycle, kami ay talakayin ang isang maliit na mamaya.

Cycle sa estilo para sa bawat

Foreach Java cycle ay palaging ginagamit para sa mga sunud-uuri ng mga hanay ng mga elemento o anumang istruktura ng data at magsagawa sa kanila ng ilang mga paulit-ulit na mga operasyon. Halimbawa na binigay para sa mga form operator ay ipinakita sa ibaba:

Bilang isang pag-ulit variable na ipinahayag pangalan, ang isang dati nang idineklara pangalan array hilera operator ay gumaganap ang pangalawang argumento. Ang pangalan ng variable ay hindi naman gawin ang mga halaga ng bawat elemento ng array hanggang ang lahat ng mga elemento nito ay nahango. Dapat ito ay nabanggit na ang mga variable na uri ay dapat na magkatugma sa ang uri ng mga elemento na naka-imbak sa array. Gayundin, ang pangalan ng variable ay magagamit ng eksklusibo para sa pagbabasa at pagtatangka upang baguhin ito ay hindi humahantong sa isang pagbabago ng mga sangkap sa array.

Operator cycle tuluy-tuloy

May tatlong mga operator cycle interrupts: break na, bumalik at magpatuloy. Ang unang dalawang ay magagawang ganap na ihinto ang work cycle, at patuloy na gagana lamang interrupts ang kasalukuyang pag-ulit. Kung ikaw ay gumagamit sa iyong code sadyang walang katapusang cycle ng Java, ang mga operator ay dapat na naroroon sa loob nito. Isaalang-alang ang isang simpleng halimbawa ng paggamit ng break na:

Kahit na ang pahayag na ito ay ibinigay para sa 11 iteration, pinaandar 8 lamang dahil, kapag ang counter i ay katumbas ng 7, trabaho na kalagayan kung saan ang katawan ay may isang break na pahayag.

return operator nagpapatakbo sa parehong paraan na may pagkakaiba na ito ay nagbibigay ng hindi lamang isang output ikot ng Java, ngunit din mula sa mga pamamaraan, na kung saan ay inilagay sa cycle na ito.

Paggamit ng pahinga pati na goto

Dapat itong makitid ang isip sa isip na ang break na interrupts lamang iyon cycle, ang katawan na kung saan siya ay direkta, ie, kung gagamitin mo ito sa isang nakapugad loop, ang mga panlabas na loop ay hindi hihinto sa kanyang trabaho. Upang gawin ito, break na pahayag ay maaaring gamitin bilang isang sibilisadong paraan ng goto.

Sa ganitong diwa, ang operator ay ginagamit kasabay ng isang label, na kung saan ay nagbibigay-daan upang ayusin ang hindi lamang ang mga output ng ikot, ngunit din mula sa anumang code block. Ang label na ay naaangkop na pinangalanang identifier na may isang colon pagkatapos nito. Ang label na ay ipinahayag sa simula ng mga bloke ng code ay minarkahan. Upang ihinto ang pagsasagawa ng isang may label na bloke, sa tamang lugar ikaw ay idedeklara: break na imya_metki. Isaalang-alang ang halimbawa sa ibaba:

Sa code, inihayag ang mga pangalan ng tatlong mga bloke na may mga label Isa, dalawa at Tatlo ayon sa pagkakabanggit. Isang break na pahayag na may label Dalawang-embed sa lahat ng tatlong mga bloke, ngunit ito nag-trigger ng isang programa sa labas ng Tatlong at Dalawang bloke at patuloy na ipatupad sa One Unit. ibig sabihin, sa console kami makakita ng dalawang mensahe: Tatlong at One.

konklusyon

Kami ay pamilyar sa mga kuru-kuro ng mga cycles sa Java, sandali at para sa mga pangunahing mga operator, pati na rin ang kanilang mga paraan ng do-habang, at para sa bawat isa, ayon sa pagkakabanggit. Para sa isang mas mahusay na pang-unawa inirerekumenda namin upang magsanay sa paggamit ng mga operator sa iba't-ibang mga form, pati na rin ang iba't-ibang paraan upang ihinto ang mga ito at lumipat mula sa isang bloke papunta sa iba.