Lekce 9 - Cyklus for v Javě
V předešlém cvičení, Řešené úlohy k 7.-8. lekci Javy, jsme si procvičili nabyté zkušenosti z předchozích lekcí.
Nyní přejdeme k cyklům, po dnešním Java tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni programovat rozumné aplikace v Javě.
Cykly
Jak již slovo cyklus napoví, něco se bude opakovat. Když chceme v programu něco udělat 100x, jistě nebudeme psát pod sebe 100x ten samý kód, ale vložíme ho do cyklu. Cyklů máme několik druhů, vysvětlíme si, kdy který použít. Samozřejmě si ukážeme praktické příklady.
Cyklus for
Tento cyklus má stanovený pevný počet opakování a
hlavně obsahuje tzv. řídící proměnnou (celočíselnou),
ve které se postupně během běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu
for
je následující:
for (promenna; podminka; prikaz)
promenna
je řídící proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji0
, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedyint i = 0
. Samozřejmě si můžeme proměnnoui
vytvořit někde nad cyklem a už nemusíme psát slovíčkoint
, bývá ale zvykem používat právěint i
.podminka
je podmínka vykonání dalšího kroku cyklu. Jakmile nebude platit, cyklus se ukončí. Podmínka může být např (i < 10
).prikaz
nám říká, co se má v každém kroku s řídící proměnnou stát. Tedy zda se má zvýšit nebo snížit. K tomu využijeme speciálních operátorů++
a--
, ty samozřejmě můžete používat i úplně běžně mimo cyklus, slouží ke zvýšení nebo snížení proměnné o1
.
Příklady užití cyklu
Pojďme si udělat několik jednoduchých příkladů na procvičení
for
cyklu.
Klepání na dveře
Většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty co ne, budeme simulovat situaci, kdy klepe na dveře své sousedky. Vždy 3x zaklepe a poté zavolá: "Penny!". Náš kód by bez cyklů vypadal takto:
{JAVA_CONSOLE}
System.out.println("Knock");
System.out.println("Knock");
System.out.println("Knock");
System.out.println("Penny!");
{/JAVA_CONSOLE}
My ale už nic nemusíme otrocky opisovat:
{JAVA_CONSOLE}
for (int i = 0; i < 3; i++) {
System.out.println("Knock");
}
System.out.println("Penny!");
{/JAVA_CONSOLE}
Výstup programu:
Konzolová aplikace
Knock
Knock
Knock
Penny!
Cyklus proběhne 3x, zpočátku je v proměnné i
nula, cyklus
vypíše Knock
a zvýší proměnnou i
o jedna. Poté
běží stejně s jedničkou a dvojkou. Jakmile je v proměnné i
trojka, již nesouhlasí podmínka i < 3
a cyklus končí. O
vynechávání složených závorek platí to samé, co u podmínek. V tomto
případě tam nemusí být, protože cyklus spouští pouze jediný příkaz.
Nyní můžeme místo trojky napsat do deklarace cyklu desítku.
Řada
Příkaz se spustí 10x aniž bychom psali něco navíc. Určitě vidíte, že cykly jsou mocným nástrojem.
Zkusme si nyní využít toho, že se nám proměnná inkrementuje. Vypišme si čísla od jedné do deseti a za každým mezeru:
{JAVA_CONSOLE}
for (int i = 1; i <= 10; i++) {
System.out.printf("%d ", i);
}
{/JAVA_CONSOLE}
Vidíme, že řídící proměnná má opravdu v každé iteraci (průběhu) jinou hodnotu.
Pokud vás zmátlo použití metody printf()
, můžeme místo
ní použít pouze metodu print()
, která na rozdíl od metody
println()
po vypsání neodřádkuje:
{JAVA_CONSOLE}
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
{/JAVA_CONSOLE}
Malá násobilka
Nyní si vypíšeme malou násobilku (násobky čísel 1
až
10
, vždy do deseti). Stačí nám udělat cyklus od 1
do 10
a proměnnou vždy násobit daným číslem. Mohlo by to
vypadat asi takto:
{JAVA_CONSOLE}
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 2) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 3) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 4) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 5) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 6) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 7) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 8) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 9) + " ");
}
System.out.println();
for (int i = 1; i <= 10; i++) {
System.out.print((i * 10) + " ");
}
{/JAVA_CONSOLE}
Výstup programu:
Konzolová aplikace
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Program funguje hezky, ale pořád jsme toho dost napsali. Pokud vás napadlo, že v podstatě děláme 10x to samé a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání vložit dva cykly do sebe:
{JAVA_CONSOLE}
System.out.println("Malá násobilka pomocí dvou cyklů:");
for (int j = 1; j <= 10; j++) {
for (int i = 1; i <= 10; i++) {
System.out.print((i * j) + " ");
}
System.out.println();
}
{/JAVA_CONSOLE}
Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme
použít u obou cyklů proměnnou i
, protože jsou vložené do
sebe. Proměnná j
nabývá ve vnějším cyklu hodnoty
1
až 10
. V každé iteraci (rozumějte průběhu)
cyklu je poté spuštěn další cyklus s proměnnou i
. Ten je nám
již známý, vypíše násobky, v tomto případě násobíme proměnnou
j
. Po každém běhu vnitřního cyklu je třeba odřádkovat, to
vykoná metoda System.out.println()
.
Mocnina čísla
Udělejme si ještě jeden program, na kterém si ukážeme práci s vnější proměnnou. Aplikace bude umět spočítat mocninu s přirozeným exponentem:
{JAVA_CONSOLE}
Scanner scanner = new Scanner(System.in);
System.out.println("Mocninátor");
System.out.println("==========");
System.out.println("Zadejte základ mocniny: ");
int zaklad = Integer.parseInt(scanner.nextLine());
System.out.println("Zadejte exponent: ");
int exponent = Integer.parseInt(scanner.nextLine());
int vysledek = 1;
for (int i = 0; i < exponent; i++) {
vysledek = vysledek * zaklad;
}
System.out.println("Výsledek: " + vysledek);
System.out.println("Děkuji za použití mocninátoru");
{/JAVA_CONSOLE}
Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že
například 23 = 2 * 2 * 2. Tedy
an spočítáme tak, že si vytvoříme proměnnou s
hodnotou 1
. To je výsledek, který bychom dostali při nulovém
exponentu 20 = 1. Pokud bude exponent
0
, cyklus se nespustí. V opačném případě budeme naši
proměnnou postupně v cyklu násobit n
krát a
a
výsledek si budeme postupně ukládat. Pokud jste to nestihli, máme tu
samozřejmě lekci s
algoritmem výpočtu libovolné mocniny. Vidíme, že naše proměnná
vysledek
je v těle cyklu normálně přístupná. Pokud si však
nějakou proměnnou založíme v těle cyklu, po skončení cyklu zanikne a již
nebude přístupná:
Konzolová aplikace
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru
Už tušíme, k čemu se cyklus for
využívá. Zapamatujme si,
že je počet opakování pevně daný.
Ukázka zacyklení
Do proměnné cyklu bychom neměli nijak zasahovat ani dosazovat, program by se mohl tzv. zacyklit. Zkusme si ještě poslední, odstrašující příklad:
{JAVA_CONSOLE}
// tento kód je špatně
for (int i = 1; i <= 10; i++) {
i = 1;
}
{/JAVA_CONSOLE}
Au, vidíme, že program se zasekl. Cyklus stále inkrementuje proměnnou
i
, ale ta se vždy sníží na hodnotu 1
. Nikdy tedy
nedosáhne hodnoty > 10
, cyklus nikdy neskončí. Program
zastavíme tlačítkem Stop u okna konzole. To je pro dnešní lekci
vše 🙂
V příští lekci, Cyklus while v Javě, se budeme ještě věnovat cyklům. Naučíme se
používat while
cyklus a vylepšíme naši kalkulačku.
Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.
Stáhnout
Stažením následujícího souboru souhlasíš s licenčními podmínkami
Staženo 1045x (36.52 kB)
Aplikace je včetně zdrojových kódů v jazyce Java