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 tak 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ídá, něco se bude opakovat. Když chceme v programu něco udělat stokrát, jistě nebudeme stokrát psát pod sebe tentýž kód. Místo toho jej vložíme do cyklu. Cyklů máme více druhů. Samozřejmě si vysvětlíme, kdy který použít, a ukážeme si praktické příklady.

Cyklus for

Tento cyklus má stanovený pevný počet opakování a hlavně obsahuje tzv. řídicí proměnnou (celočíselnou), ve které se postupně za běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu for je následující:

for (promenna; podminka; prikaz)

• promenna je řídicí proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji 0, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedy int i = 0. Samozřejmě si můžeme proměnnou i vytvořit někde nad cyklem a už nemusíme psát slovíčko int, bývá ale zvykem používat právě int i.
• podminka je podmínka vykonání dalšího kroku cyklu. Jakmile nebude podmínka 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 řídicí proměnnou stát. Tedy zda se má zvýšit nebo snížit. K tomu využijeme speciální operátory ++ a --. Ty samozřejmě můžete úplně běžně používat i mimo cyklus, slouží ke zvýšení nebo snížení proměnné o 1.

Příklady použ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, kteří ho neznají, budeme simulovat situaci, kdy Sheldon klepe na dveře své sousedky. Vždy třikrát 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 už ale nic otrocky opisovat nemusíme:

{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 třikrát. Zpočátku je v proměnné i nula, cyklus vypíše Knock a proměnnou i zvýší o jedna. Cyklus poté běží stejně s jedničkou i 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í totéž co u podmínek. V tomto případě tam nemusí být, protože cyklus spouští pouze jediný příkaz. Nyní můžeme do deklarace cyklu místo trojky napsat desítku.

Řada

Příkaz se spustí desetkrát, aniž napíšeme něco navíc. Určitě vidíte, že cykly jsou mocným nástrojem.

Zkusme 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 řídicí 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(). Ta 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. Kód by mohl 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 stále jsme toho museli dost napsat. Pokud vás napadlo, že v podstatě děláme desetkrát totéž a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání v tom, abychom vložili 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ějme 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 ještě 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řipomeneme, že například 2³ = 2 * 2 * 2. Tedy aⁿ 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 2⁰ = 1. Pokud bude exponent 0, cyklus se nespustí. V opačném případě budeme naši proměnnou postupně v cyklu násobit nkrát a a výsledek si budeme postupně ukládat. Pokud k mocninám potřebujete více informací, 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 proměnná zanikne a již přístupná nebude:

Konzolová aplikace
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru

Nyní už tedy víme, k čemu se cyklus for využívá. Zapamatujme si, že počet opakování je 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 proto 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š.