Rozbití smyčky java. Smyčky v Javě. Příklady a popis: for - Java loop

Když potřebujete stejnou akci provést několikrát nebo do určité podmínky, smyčky přijdou na pomoc.

V jazyk Java Existuje několik způsobů, jak vytvořit cykly. Jak už asi tušíte, všechny je zvážíme.

První způsob, jak deklarovat smyčku, je použít následující konstrukci: for (podmínka zahájení smyčky; koncová podmínka; krok, kterým smyčka půjde) ( tělo smyčky )

Pojďme rovnou k příkladům. Řekněme, že máme za úkol 10x zobrazit frázi „ahoj světe“. Pokud nepoužíváte smyčky, můžete napsat System.out.println("Ahoj světe"); desetkrát a problém vyřešte. K tomuto účelu použijeme smyčky. Vytvořte novou třídu a pojmenujte ji například CuclesInJava. Nyní deklarujte podmínku smyčky (nechť je 0), koncovou podmínku 10 a krok. Půjdeme krok za krokem. Do těla smyčky vložte řádek System.out.println("Ahoj světe");

Zde je příklad kódu:

Výsledkem tohoto kódu bude 10 po sobě jdoucích řádků fráze "Ahoj světe!".

Co takhle napsat něco složitějšího. Ty základní jsme se již naučili. Pojďme je využít.

Napišme si jednoduchou aplikaci, která při každém kroku zobrazí řádek s upozorněním + nějaká proměnná se rovná 5. Mám velmi špatnou představivost))

Nejprve napíšeme kód, který bude přijímat proměnnou zadanou z konzole jako vstup. V předchozím článku jsem uvedl příklad tohoto kódu a dohodli jsme se, že později vysvětlím, jak funguje a odkud pochází. Prozatím to budeme používat:

Dále je potřeba napsat smyčku, která bude začínat od nuly a počítat do deseti (jako v předchozím příkladu). Do těla cyklu napíšeme podmíněný příkaz, který zkontroluje, zda je tato proměnná rovna 5, a pokud ano, zobrazíme řetězec „OK“. Zde je to, co jsem dostal:

import java.util.Scanner ;

veřejná třída CuclesInJava(

proměnná int = scanner.nextInt(); //k tomu se dostaneme postupně a pak bude jasné, jak to funguje

for (int i = 1; i< 10 ; i++ ) {

int novaPromenna = i + promenna;

if (nováProměnná== 5) (

Nedopadlo to moc dobře. Tímto příkladem jsem chtěl ukázat, jak můžete použít smyčky s větvemi ve spojení.

Dalším způsobem, jak deklarovat smyčky, je while (podmínka je pravdivá) (blok kódu, který se má provést). Tento design má jinou podobu:

do (blok kódu k provedení) while (podmínka je pravdivá). Rozdíl mezi prvním a druhým je v tom, že druhý provede jeden cyklus bez ohledu na to, zda je podmínka pravdivá nebo ne. Můžete si myslet sami: nejprve spustíme kód a poté zkontrolujeme podmínku. A i když podmínka není pravdivá, kód se stejně provede jednou, a to v době, kdy se podmínka poprvé zkontroluje v první formě konstrukce, a dokud nebude pravdivá, kód se nespustí.

Kód by měl být intuitivní. Myslím, že stojí za zmínku, že s konstrukcemi while a do-while můžete "smyčka" program, pokud nezaregistrujete nebo nesprávně zaregistrujete výstupní podmínku ze smyčky. Podívejte se na výše uvedený příklad a přemýšlejte o tom, co by se stalo, kdybych napsal i++ místo i-; nebo místo i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

No, příklad s do-while:

Myslím, že tímto bychom mohli dokončit článek o smyčky v Javě. Jak vidíte, návrhy nejsou příliš složité, ale velmi užitečné. Budou obzvláště užitečné, když se seznámíme s poli a řetězci.

Smyčka Java While Do je příkaz, který vám umožňuje spustit stejný kus kódu vícekrát. Tuto smyčku lze použít k opakování akcí, když jsou splněny podmínky.

zatímco smyčka

Smyčka while je nejjednodušší vytvořit v jazyce Java. Skládá se z klíče while, podmínky smyčky a těla smyčky:

while (podmínka) ( // tělo smyčky )

Každý samostatný běh těla smyčky je považován za iteraci. Před každou iterací se vyhodnotí podmínky smyčky. Jeho tělo se provede pouze tehdy, je-li podmínka smyčky při vyhodnocení pravdivá.

Iterace cyklu něco změní a v určitém okamžiku se podmínka vyhodnotí jako false , načež se cyklus ukončí. Smyčka, jejíž podmínka nikdy nevrátí hodnotu false, se provede nekonečněkrát. Takové cykly se nazývají nekonečné.

Příklad

int num = 0; zatímco (č< 10) { System.out.println(num); num++; }

Tento příklad zobrazuje čísla od 0 do 9. Pojďme si projít kód krok za krokem. Nejprve inicializujeme proměnnou num s hodnotou 0 . Toto bude čítač smyček. Když program dosáhne while , vyhodnotí se stav smyčky. V našem případě 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

Po prvním "spuštění" je podmínka Java While Loop vyhodnocena podruhé. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

Konečná iterace začíná, když je hodnota num 9 . Počitadlo smyčky se vytiskne naposledy a hodnota se zvýší na 10 . Tentokrát nelze spustit novou iteraci, protože podmínka smyčky je vyhodnocena jako false . Protože 10 není menší než 10.

Smyčka tedy běží tak dlouho, dokud je splněna podmínka smyčky. Vyzbrojeni těmito znalostmi můžete vytvářet složitější a funkční cykly. Pojďme iterovat pole:

Jména řetězců = ("Doc", "Dopey", "Stydlivý", "Nevrlý", "Kýchavý", "Ospalý", "Happy"); int index = 0; zatímco (index< names.length) { System.out.println(names); index++; }

Koncept tohoto příkladu je podobný předchozímu. Inicializujeme čítač smyček a začneme iterovat pole, dokud se nezobrazí všechny prvky. Výsledkem je, že iterování přes pole je docela běžné a Java má pro to vhodnější konstrukci, smyčku For.

smyčka do-while

Cyklus while do Java je podobný cyklu while , ale má důležitý rozdíl: na rozdíl od while se zde podmínka kontroluje na konci každé iterace. To znamená, že smyčka do-while se vždy provede alespoň jednou:

do ( // tělo smyčky ) while (podmínka);

Příklad

do-while nejprve provede tělo cyklu a poté vyhodnotí jeho podmínky. V závislosti na výsledku se smyčka zastaví nebo začne další iterace. Podívejme se na jednoduchou hru s hádáním názvu:

Scanner scanner = new Scanner(System.in); Odhad řetězce; do ( System.out.print("Hádej jméno: "); hádej = scanner.nextLine(); ) while (!"Daffy Duck".equals(hádej)); System.out.println("Gratuluji! Uhádli jste mé jméno!");

Tento příklad Java používá Scanner k analýze vstupu ze system.ini . Toto je standardní vstupní kanál, který ve většině případů spolupracuje s klávesnicí. Jednoduše řečeno, jen čteme text, který hráč zadá.

Hra vyžaduje, abyste se uživatele zeptali alespoň jednou, a to tak dlouho, dokud hráč zadá správné odpovědi. Smyčka do-while je pro takové případy ideální. V těle smyčky získáme uživatelskou hodnotu a následně se kontroluje správnost odpovědi. Smyčka by měla běžet, dokud se vstup uživatele nerovná Daffy Duck . Pokud je obdržena správná odpověď, smyčka se zastaví a gratulujeme hráči k vítězství.

Na závěr

Tato publikace je překladem článku " Smyčky Chvíle a Do-While na Javě za pět minut» připravil přátelský projektový tým

Smyčka je část programu, která se mnohokrát opakuje.

V Javě existují dva typy smyček: typ „while“ a typ „n-times“.

První typ „až“ je navržen tak, aby opakoval nějakou akci, dokud není splněna nějaká podmínka. Příklad: zvyšujte číslo o 5, dokud se nestane třemi číslicemi.

Druhý typ „n-krát“ je navržen tak, aby opakoval některé akce předem určený početkrát. Příklad: vynásobte číslo samo o sobě 4krát.

While Loop (příkazy while a do...while)

Příkaz while opakuje zadané akce, dokud je jeho parametr pravdivý.

Taková smyčka bude například provedena 4krát a na obrazovce se zobrazí „1 2 3 4“:

Int i = 1; zatímco já< 5) { System.out.print(i + " "); i++; }

Taková smyčka nebude nikdy provedena a na obrazovce se nic nezobrazí:

Int i = 1; zatímco já< 0) { System.out.print(i + " "); i++; }

Taková smyčka bude prováděna neomezeně dlouho a na obrazovce se zobrazí „1 2 3 4 5 6 7 ...“:

Int i = 1; while (true) ( ​​​​System.out.print(i + " "); i++; )

Podmínka, která určuje, zda se bude smyčka opakovat, se kontroluje před každým krokem smyčky, včetně před úplně prvním. Říkají, co se děje předběžná kontrola podmínky.

Existuje smyčka while s po ověření podmínky. K jeho napsání se používá konstrukce příkazů do ... while.

Taková smyčka se provede 4krát a na obrazovce se zobrazí „2 3 4 5“:

< 5);

Taková smyčka se provede jednou a na obrazovce se zobrazí „2“:

Int i = 1; do ( i++; System.out.print(i + " "); ) zatímco (i< 0);

Tělo cyklu do...while se provede alespoň jednou. Tento operátor je vhodné použít, když je třeba nějakou akci v programu provést alespoň jednou, ale za určitých podmínek ji bude nutné opakovat mnohokrát.

Podívejte se na následující program (uhodne náhodné celé číslo ze segmentu a požádá uživatele, aby ho uhádl zadáním možností z klávesnice, dokud uživatel neuhodne číslo, program ho vyzve a řekne mu více nebo méně než uhádnuté číslo než to, co uživatel zadal):

Importovat java.util.Scanner; public class Main ( public static void main(String args) ( // prog - číslo vytvořené programem // user - číslo zadané uživatelem int prog, user; // Vygeneruje náhodné celé číslo od 1 do 10 prog = (int)(Math. random() * 10) + 1; System.out.println("Uhádl jsem číslo od 1 do 10, hádej."); System.out.print("Zadejte své číslo: ") ; Vstup skeneru = new Scanner( System.in); // Zkontrolujte, zda je ve vstupním toku celé číslo if(input.hasNextInt()) ( do ( // Přečte celé číslo ze vstupního toku user = input.nextInt( ); if(user == prog) ( System.out.println("Uhádli jste!"); ) else ( // Zkontrolujte, zda je číslo v rozsahu if (uživatel > 0 && uživatel<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Proveďte v programu následující změny:

Program by měl myslet na číslo nikoli ze segmentu , ale na celé číslo ze segmentu od [−10;10], kromě nuly. Zároveň se snažte zajistit, aby distribuce náhodných čísel generovaných programem byla rovnoměrná (tj. v případě vypadnutí nuly ji nelze jednoduše nahradit nějakým jiným číslem, např. 1, protože pak 1 vypadnou s dvojnásobnou pravděpodobností než ostatní čísla).

Program by měl upozornit uživatele, že udělal chybu ve znaménku, pokud program uhodl kladné číslo a uživatel zadal záporné číslo. A naopak.

Typ smyčky "n-krát" (příkaz pro)

Příkaz for obsahuje tři parametry. První se nazývá inicializace, druhá je podmínka opakování a třetí je iterace.

For (inicializace; podmínka; iterace) ( // tělo smyčky, tj. cyklicky se opakující akce )

V prvním parametru se většinou volí nějaká proměnná, pomocí které se bude počítat počet opakování smyčky. Říká se tomu pult. Čítač dostane nějakou počáteční hodnotu (ukazují, od jaké hodnoty se bude měnit).

Ve druhém parametru je indikováno nějaké omezení čítače (označují na jakou hodnotu se změní).

Třetí parametr určuje výraz, který změní čítač po každém kroku smyčky. Obvykle se jedná o zvýšení nebo snížení, ale můžete použít jakýkoli výraz, kde bude čítači přiřazena nějaká nová hodnota.

Před prvním krokem smyčky je čítači přiřazena počáteční hodnota (provede se inicializace). To se stane pouze jednou.

Před každým krokem smyčky (ale po inicializaci) se kontroluje podmínka opakování, pokud je pravdivá, pak se tělo smyčky provede ještě jednou. Zároveň se tělo smyčky nesmí provést ani jednou, pokud je podmínka v době první kontroly nepravdivá.

Po dokončení každého kroku smyčky a před začátkem dalšího (a tedy před kontrolou podmínky opakování) se provede iterace.

Následující program vytiskne na obrazovku čísla od 1 do 100:

Pro (int i = 1; i<= 100; i++) { System.out.print(i + " "); }

Následující program vytiskne na obrazovku čísla od 10 do -10:

For (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Prezentovaný program zobrazuje lichá čísla od 1 do 33:

Pro (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }

Prezentovaný program vypočítá součet prvků fragmentu sekvence 2, 4, 6, 8, ... 98, 100. Takže:

int součet = 0; // Zde shromáždíme výsledek pro (int j = 2; j

Prezentovaný program zvýší číslo z proměnné A k přirozené síle z proměnlivého n:

Dvojité a = 2; int n = 10; dvojitá res = 1; // Zde shromáždíme výsledek pro (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Prezentovaný program zobrazí prvních 10 prvků sekvence 2n+2, kde n=1, 2, 3…:

Pro (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }

Prezentovaný program zobrazí prvních 10 prvků sekvence 2a n−1 +3, kde a 1 =3:

Int a = 3; pro (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

V jednom cyklu můžete nastavit několik čítačů najednou. V tomto případě je několik výrazů v iteraci a inicializaci odděleno čárkami. Můžete zadat pouze jednu podmínku opakování, ale může to být výraz obsahující několik čítačů najednou.

Prezentovaný program zobrazí prvních 10 prvků sekvence 2a n−1 -2, kde a 1 =3:

Pro (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Prezentovaný program zobrazí následující sekvenci "0 -1 -4 -9 -16 -25":

Pro (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Předčasné ukončení smyčky (příkaz break)

Smyčku typu „while“ i smyčku typu „n-krát“ lze dokončit před plánem, pokud zavoláte operátora uvnitř těla smyčky přestávka. V tomto případě dojde k okamžitému opuštění smyčky, dokonce ani aktuální krok nebude dokončen (tj. pokud po přestávce byly nějaké další příkazy, nebudou provedeny).

V důsledku následujícího příkladu se na obrazovce zobrazí pouze čísla „1 2 3 4 End“:

Pro (int a=1; a

Když program provede smyčku popáté (do smyčky vstoupí s čítačem rovným 5), bude okamžitě zkontrolován a podmínka, za které se příkaz break vykoná, bude pravdivá. Zbytek těla smyčky (výstup na obrazovku) již nebude produkován: program okamžitě přejde k provádění operací specifikovaných po cyklu a dále.

Pomocí příkazu break můžete přerušit záměrně nekonečnou smyčku. Příklad (na obrazovce se zobrazí „100 50 25 12 6 3 1 0“ a poté se smyčka zastaví):

int s = 100; while (true) ( ​​​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Má smysl volat příkaz break pouze tehdy, když nastane nějaká podmínka, jinak bude smyčka v prvním kroku ukončena před plánem.

int a; for (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Ve výše uvedeném příkladu se výstup ve smyčce na obrazovku nestane ani jednou, a když proměnná A se po smyčce zobrazí na obrazovce, ukáže se, že se jeho hodnota nikdy nezměnila, tj. zobrazí se „a=25“ (a nic jiného).

Všimněte si také, že proměnná byla deklarována před spuštěním smyčky. Když je proměnná deklarována v parametrech smyčky, ukazuje se mimo ni jako nepřístupná a v tomto případě bylo požadováno jinak - zjistit, jakou hodnotu bude mít čítač po skončení smyčky.

Úkoly

Napište program, který zobrazí všechna čtyřmístná čísla v sekvenci 1000 1003 1006 1009 1012 1015 ….

Napište program, který zobrazí prvních 55 prvků sekvence 1 3 5 7 9 11 13 15 17 ….

Napište program, který zobrazí všechny nezáporné prvky sekvence 90 85 80 75 70 65 60 ….

Napište program, který zobrazí prvních 20 prvků sekvence 2 4 8 16 32 64 128 ….

Vytiskněte všechny členy posloupnosti 2a n-1 -1, kde a 1 = 2, které jsou menší než 10 000.

Vytiskněte všechny dvouciferné členy posloupnosti 2a n-1 +200, kde a 1 = -166.

Napište program, který vypočítá faktoriál přirozeného čísla n, které uživatel zadá z klávesnice.

Zobrazit všechny kladné dělitele přirozeného čísla zadané uživatelem z klávesnice.

Zkontrolujte, zda je přirozené číslo zadané uživatelem z klávesnice prvočíslo. Snažte se neprovádět zbytečné akce (například poté, co jste našli alespoň jednoho netriviálního dělitele, je již jasné, že číslo je složené a nemusíte pokračovat v kontrole). Všimněte si také, že nejmenší dělitel přirozeného čísla n, pokud existuje, se nutně nachází v segmentu.

Napište program, který zobrazí prvních 12 prvků posloupnosti 2a n-2 -2, kde a 1 =3 a a 2 =2.

Zobrazte prvních 11 členů Fibonacciho posloupnosti. Připomínáme, že první a druhý člen posloupnosti se rovnají jedničkám a každý další je součtem dvou předchozích.

Pro přirozené číslo zadané uživatelem z klávesnice vypočítejte součet všech jeho číslic (neví se předem, kolik číslic v čísle bude).

Ve městě N se jezdí tramvají na papírové trhací jízdenky. Tramvajová vozovna objednává v místní tiskárně každý týden roli jízdenek s čísly od 000001 do 999999. „Šťastná“ jízdenka je taková, ve které se součet prvních tří číslic čísla rovná součtu poslední tři číslice, jako například na jízdenkách s čísly 003102 nebo 567576. Tramvajová vozovna se rozhodla věnovat majiteli každé šťastné jízdenky suvenýr a nyní je zvědavá, kolik suvenýrů bude potřeba. Pomocí programu spočítejte, kolik šťastných lístků je v jednom hodu?

City N má velký sklad s 50 000 různými policemi. Pro pohodlí pracovníků se vedení skladu rozhodlo objednat desku s číslem od 00001 do 50000 pro každý regál v místní tiskárně, ale při tisku desek se ukázalo, že tiskárna číslo 2 nevytiskla. z důvodu poruchy, takže všechny štítky, které obsahovaly jeden nebo více dvou (například 00002 nebo 20202) - musí být přetypovány. Napište program, který bude počítat, kolik těchto chybných štítků bylo ve vadné šarži.

Elektronické hodiny ukazují čas ve formátu od 00:00 do 23:59. Spočítejte, kolikrát za den se stane, že se vlevo od dvojtečky zobrazí symetrická kombinace pro kombinaci vpravo od dvojtečky (například 02:20, 11:11 nebo 15:51).

V americké armádě je číslo 13 považováno za nešťastné a v japonské - 4. Před mezinárodními cvičeními se velitelství ruské armády rozhodlo vyloučit čísla vojenské techniky obsahující čísla 4 nebo 13 (například 40123, 13313, 12345 nebo 13040), abychom neudělali ostudu zahraničním kolegům. Pokud má armáda k dispozici 100 000 jednotek vojenské techniky a každé bojové vozidlo má číslo od 00001 do 99999, kolik čísel bude muset být vyloučeno?

2010, Alexej Nikolajevič Kostin. Katedra TIDM Matematické fakulty Moskevské státní pedagogické univerzity.

Poslední aktualizace: 31.10.2018

Dalším typem řídicích struktur jsou smyčky. Cykly umožňují v závislosti na určitých podmínkách provést určitou akci mnohokrát. Jazyk Java má následující typy smyček:

pro smyčku

Cyklus for má následující formální definici:

Pro ([inicializace počítadla]; [podmínka]; [změna počítadla]) ( // akce )

Zvažte standardní smyčku for:

Pro (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }

První část deklarace smyčky, int i = 1, vytvoří a inicializuje čítač i. Počítadlo nemusí být typu int . Může to být jakýkoli jiný číselný typ, například plovoucí. Před provedením smyčky bude hodnota čítače rovna 1. V tomto případě je to stejné jako deklarace proměnné.

Druhá část je podmínka, za které bude smyčka provedena. V tomto případě bude smyčka běžet, dokud i nedosáhne 9.

A třetí částí je zvýšení počítadla o jednu. Opět nemusíme zvyšovat o jednu. Můžete snížit: i-- .

Výsledkem je, že blok smyčky proběhne 8krát, dokud se hodnota i nestane rovna 9. A pokaždé se tato hodnota zvýší o 1.

Při deklaraci smyčky nemusíme zadávat všechny podmínky. Můžeme psát například takto:

Int i = 1; for (; ;)( System.out.printf("Čtverec %d je %d \n", i, i * i); )

Definice cyklu zůstává stejná, pouze bloky v definici jsou nyní prázdné: for (; ;) . Nyní neexistuje žádná inicializovaná proměnná čítače, žádná podmínka, takže smyčka bude běžet navždy - nekonečná smyčka.

Nebo můžete vynechat několik bloků:

Int i = 1; Protože já<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }

Tento příklad je ekvivalentní prvnímu příkladu: máme také čítač, jen je vytvořen mimo smyčku. Máme podmínku provedení smyčky. A přírůstek počítadla je již v samotném bloku for.

Cyklus for může definovat a spravovat více proměnných najednou:

int n = 10; for(int i = 0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }

udělat smyčku

Smyčka do nejprve provede kód smyčky a poté zkontroluje podmínku v příkazu while. A i když je tato podmínka pravdivá, cyklus se opakuje. Například:

int j = 7; do( System.out.println(j); j--; ) while (j > 0);

V tomto případě se kód smyčky spustí 7krát, dokud j nebude nula. Je důležité poznamenat, že cyklus do zaručuje, že akce budou provedeny alespoň jednou, i když podmínka v příkazu while není pravdivá. Můžeme tedy napsat:

int j = -1; do( System.out.println(j); j--; ) while (j > 0);

I když je j zpočátku menší než 0, smyčka se přesto jednou provede.

zatímco smyčka

Cyklus while okamžitě zkontroluje pravdivost nějaké podmínky, a pokud je podmínka pravdivá, provede se kód smyčky:

int j = 6; while (j > 0)( System.out.println(j); j--; )

pokračovat a přerušit příkazy

Příkaz break vám umožňuje cyklus kdykoli ukončit, i když cyklus ještě nedokončil svou práci:

Například:

< nums.length; i++){ if (nums[i] >10) přestávka; System.out.println(nums[i]); )

Protože smyčka kontroluje, zda je prvek pole větší než 10, neuvidíme poslední dva prvky na konzole, protože když je nums[i] větší než 10 (to znamená rovno 12), příkaz break bude fungovat a smyčka skončí.

Pravda, také neuvidíme poslední prvek, který je menší než 10. Nyní to uděláme tak, že pokud je číslo větší než 10, smyčka nekončí, ale jde jednoduše k dalšímu prvku. K tomu použijeme příkaz continue:

int nums = nový int (1, 2, 3, 4, 12, 9); for (int i = 0; i< nums.length; i++){ if (nums[i] >10) pokračovat; System.out.println(nums[i]); )

V tomto případě, když provádění smyčky dosáhne čísla 12, což nesplňuje podmínku testu, program toto číslo jednoduše přeskočí a přejde k dalšímu prvku pole.

V tomto tutoriálu se naučíme, jak znovu spustit části našeho kódu kontrolovaným způsobem, když se podíváme na různé typy smyček v Jáva. Další informace o cyklech: zatímco, dělat-zatímco, pro. Pokusíme se určit, v jakých případech je který z cyklů nejvhodnější k použití.

Následně se krátce podíváme na téma náhodných čísel ( náhodnýčísla). Pojďme se podívat Jáva-Třída Náhodný a jak nám může pomoci v naší hře.

Smyčka, jak název napovídá, je způsob, jak provést stejnou část kódu požadovaný počet opakování (zatímco výsledek spuštění kódu ve smyčce se nemusí nutně opakovat). Počet opakování provedení smyčky může být buď předem určen, nebo může být neznámý samotnému programátorovi. Zvážíme hlavní typy smyček, které nám jazyk nabízí k použití. Jáva. A pak některé z nich zavedeme do naší hry, čímž ji vylepšíme.

zatímco smyčka

Cyklus zatímco má nejjednodušší syntaxi. Pamatovat -li- návod, který jsme studovali o něco dříve. Ve výrazu podmíněného operátoru -li(co je uzavřeno v závorkách za slovem -li) můžete vložit téměř jakoukoli kombinaci operátorů a proměnných. Pokud je výraz pravdivý ( skutečný), pak kód uzavřený v těle bloku -li bude provedena. Podobně v cyklu zatímco vložíme výraz, který lze vyhodnotit skutečný nebo Nepravdivé, jak je znázorněno v tomto kódu:

int x = 10; while(x > 0)( x--; //x se sníží o jednu každou iteraci cyklu)

Co se tam děje? První věc mimo smyčku zatímco deklarovali jsme proměnnou X typ int a přidělil toto proměnná hodnota"10". Poté začne cyklus zatímco, v jakém stavu je napsáno “ x > 0"- to znamená, že kód napsaný v těle smyčky zatímco bude prováděno tak dlouho jako proměnná X více 0 a stav nedosáhne hodnoty Nepravdivé. Kód se tedy provede 10krát (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). V prvním průchodu smyčkou x=10, ve druhém 9 , ve třetím 8 atd. A kdy X se bude rovnat 0 , pak nebude splněna podmínka pro vstup do smyčky a program bude pokračovat od dalšího řádku po skončení smyčky.

Stejné jako u operátora -li, je možná situace, kdy se smyčka neprovede ani jednou. Podívejte se na následující příklad:

int x = 10; while(x > 10)( //nějaký kód //ale nikdy se nespustí, dokud x nebude větší než 10 )

Kromě toho neexistují žádná omezení na složitost výrazu podmínky nebo množství kódu, který lze zapsat do těla smyčky:

int playerLives = 3; int alienShips = 10; while(playerLives >0 && alienShips >0)( //Všechny kód hry zde //... //... // atd. ) //program bude pokračovat zde, když hráč žije nebo mimozemské lodě = 0

Tato smyčka bude pokračovat, dokud nebude proměnná hráč žije nebo mimozemské lodě nebude rovna nebo menší než nula. Jakmile nastane jedna z těchto podmínek, výraz v podmínce nabude hodnoty Nepravdivé a po skončení cyklu bude program pokračovat dalším řádkem.

Stojí za zmínku, že jakmile program vstoupí do těla smyčky, bude proveden, i když se podmínka smyčky stane Nepravdivé, někde v těle smyčky, protože podmínka se kontroluje pouze při vstupu:

int x = 1; while(x > 0)( x--; //x je nyní 0 a podmínka se příště vyhodnotí jako nepravda //Tento řádek se však provede //A tento //A dokonce i tento )

Ve výše uvedeném příkladu bude tělo smyčky provedeno jednou. Navíc si můžete nastavit podmínku, že smyčka poběží věčně – tomu se říká nekonečný koloběh. Zde je příklad:

int x = 0; while(true)( x++; //Budu opravdu velký!)

Opusťte jejich cyklus. Klíčové slovo přestávka

Co když opravdu potřebujeme použít nekonečná smyčka, ale abychom se mohli rozhodnout, kdy z něj vystoupit. Za tímto účelem v Jáva existuje klíčové slovo přestávka. Můžeme použít přestávka když potřebujeme „ukončit“ smyčku:

int x = 0; while(true)( x++; //budu opravdu velký! break; //Ne, nebudeš! //kód se sem nedostane)

Jistě jste již uhodli, že je možné kombinovat různé nástroje rozhodování, jako je kupř li,jiný,přepínač uvnitř naší smyčky zatímco a další cykly, které budeme uvažovat níže. Např:

int x = 0; int tooBig = 10; while(true)( x++; //Budu hodně velký! if(x == tooBig)( break; //Ne, nebudeš. ) //kód zde bude dostupný, dokud nebude x 10)

Můžete si zapsat mnohem více různých variant, ale pro nás je to důležitější praktické využití tyto znalosti, takže teď nepůjdeme do hloubky. Podívejme se na další koncept, který lze provozovat ve smyčce.

Klíčové slovo pokračovat

pokračovat funguje téměř stejně jako přestávka. Klíčové slovo pokračovat vás vykopne z těla smyčky, ale poté zkontrolujte podmíněný výraz, místo abyste pokračovali od místa, kde skončil po uzavření smyčky složené závorky, jak by se stalo přestávka. Následující příklad ukazuje použití pokračovat:

int x = 0; int tooBig = 10; int tooBigToPrint = 5; while(true)( x++; //Budu moc velký! if(x == tooBig)( break; ) //Ne, nebudeš. //kód zde bude dostupný pouze do x 10 if(x > = tooBigToPrint)( //už se nebude tisknout na obrazovku, ale smyčka bude pokračovat; ) //kód zde bude dostupný, dokud se x nestane 5 //kód pro tisk x na obrazovku )

Vysvětlení: deklarujeme a inicializujeme proměnné. Jdeme do smyčky - přičteme k hodnotě proměnné X jednotka (nyní X= 1). Kontrola "1 je 10?" — Nepravdivé- první operátor -li se neprovádí. Další kontrola"Je 1 větší nebo rovno 5?" — Nepravdivé- druhý operátor -li se neprovádí. Výstup X na obrazovku.

Zvažte případ, kdy X bude mít hodnotu 5 při vstupu do smyčky. Jdeme do smyčky - přičteme k hodnotě proměnné X jednotka (nyní X= 6). Kontrola "6 je 10?" — Nepravdivé- první operátor -li se neprovádí. Další kontrola je "6 je větší nebo rovno 5?" — skutečný- vstoupit do těla -li — pokračovat, opusťte smyčku a zkontrolujte podmínku vstupu do smyčky.

Nyní je možnost kdy X bude mít hodnotu 9 při vstupu do smyčky. Jdeme do smyčky - přičteme k hodnotě proměnné X jednotka (nyní X= 10). Kontrola "10 je 10?" — skutečný- vstoupit do těla -li — přestávka, opusťte smyčku a kód bude pokračovat za uzavírací složenou závorkou smyčky zatímco.

smyčka do-while

Téměř stejné jako předchozí smyčka, až na jednu vlastnost - podmíněný výraz bude zkontrolován za tělem smyčky. To znamená, že cyklus dělat-zatímco bude vždy proveden alespoň jednou. Podívejte se na příklad:

int x = 0; do ( x++; ) while(x< 10); //x теперь = 10

Klíčová slova přestávka,pokračovat

pro smyčku

Cyklus pro má složitější syntaxi než zatímco A dělat-zatímco, protože jeho inicializace vyžaduje trochu více manipulace. Nejprve se na to podíváme a pak si to rozebereme kousek po kousku:

For(int i = 0; i< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }

Jak to vidí kompilátor? Takhle:

For(deklarace a inicializace; podmínka; změna po každé iteraci smyčky)( // tělo smyčky )

• Deklarace a inicializace- vytvořili jsme nový typ proměnné int Se jménem i a přiřadil mu hodnotu 0 ;
• Stav– stejně jako ostatní cykly probírané dříve, i zde kontrolujeme podmínku pro zadání cyklu. Pokud je hodnota vypočtena jako skutečný, pak vstoupíme do těla smyčky;
• Změna po každém cyklu- ve výše uvedeném příkladu i++ znamená, že po dalším průchodu smyčkou se dostaneme na hodnotu proměnné i přidat jeden (1). Navíc můžeme zapsat do proměnné change and i— odečíst jeden, například:

Klíčová slova přestávka,pokračovat lze použít i v tomto cyklu.

Cyklus pro přebírá kontrolu nad inicializací, kontrolou stavu a změnou proměnné. Hned po seznámení si tento cyklus vyzkoušíme v praxi v naší aplikaci náhodná čísla A metody.