9. diel - Cyklus for v Jave

V predchádzajúcom cvičení, Riešené úlohy k 7.-8. lekcii Javy, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

Teraz prejdeme k cyklom, po dnešnom Java tutoriále už budeme mať takmer kompletnú výbavu základných konštrukcií a budeme schopní programovať rozumné aplikácie v Jave.

Cykly

Ako už slovo cyklus napovedá, niečo sa bude opakovať. Keď chceme v programe niečo urobiť 100x, určite nebudeme písať pod seba 100x ten istý kód, ale vložíme ho do cyklu. Cyklov máme niekoľko druhov, vysvetlíme si, kedy ktorý použiť. Samozrejme si ukážeme praktické príklady.

Cyklus for

Tento cyklus má stanovený pevný počet opakovaní a hlavne obsahuje tzv. riadiacu premennú (celočíselnú), v ktorej sa postupne počas behu cyklu menia hodnoty. Syntax (zápis) cyklu for je nasledovná:

for (variable; condition; command)

• variable je riadiaca premenná cyklu, ktorej nastavíme počiatočnú hodnotu (najčastejšie 0, pretože v programovaní všetko začína od nuly, nie od jednotky). Napr. teda int i = 0. Samozrejme si môžeme premennú i vytvoriť niekde nad cyklom a už nemusíme písať slovíčko int, býva ale zvykom používať práve int i.
• condition je podmienka vykonania ďalšieho kroku cyklu. Akonáhle nebude platiť, cyklus sa ukončí. Podmienka môže byť napr (i < 10).
• command nám hovorí, čo sa má v každom kroku s riadiacou premennou stať. Teda či sa má zvýšiť alebo znížiť. Na to využijeme špeciálne operátory ++ a --, tie samozrejme môžete používať aj úplne bežne mimo cyklu, slúžia na zvýšenie alebo zníženie premennej o 1.

Príklady použitia cyklu

Poďme si urobiť niekoľko jednoduchých príkladov na precvičenie for cyklu.

Klopanie na dvere

Väčšina z nás určite pozná Sheldona z The Big Bang Theory. Pre tých, čo nie, budeme simulovať situáciu, keď klope na dvere svojej susedky. Vždy 3x zaklope a potom zavolá: "Penny!". Náš kód by bez cyklov vyzeral takto:

{JAVA_CONSOLE}
System.out.println("Knock");
System.out.println("Knock");
System.out.println("Knock");
System.out.println("Penny!");
{/JAVA_CONSOLE}

My ale už nič nemusíme otrocky opisovať:

{JAVA_CONSOLE}
for (int i = 0; i < 3; i++) {
    System.out.println("Knock");
}
System.out.println("Penny!");
{/JAVA_CONSOLE}

Výstup programu:

Konzolová aplikácia
Knock
Knock
Knock
Penny!

Cyklus prebehne 3x, spočiatku je v premennej i nula, cyklus vypíše Knock a zvýši premennú i o jedna. Potom beží rovnako s jednotkou a dvojkou. Akonáhle je v premennej i trojka, už nesúhlasí podmienka i < 3 a cyklus končí. O vynechávaní zložených zátvoriek platí to isté, čo pri podmienkach. V tomto prípade tam nemusia byť, pretože cyklus spúšťa iba jediný príkaz. Teraz môžeme namiesto trojky napísať do deklarácie cyklu desiatku.

Rad

Príkaz sa spustí 10x bez toho, aby sme písali niečo navyše. Určite vidíte, že cykly sú mocným nástrojom.

Skúsme teraz využiť to, že sa nám premenná inkrementuje. Vypíšme si čísla od jednej do desiatich a za každým dajme medzeru:

{JAVA_CONSOLE}
for (int i = 1; i <= 10; i++) {
    System.out.printf("%d ", i);
}
{/JAVA_CONSOLE}

Vidíme, že riadiaca premenná má naozaj v každej iterácii (priebehu) inú hodnotu.

Pokiaľ vás zmiatlo použitie metódy printf(), môžeme namiesto nej použiť iba metódu print(), ktorá na rozdiel od metódy println() po vypísaní neodriadkuje:

{JAVA_CONSOLE}
for (int i = 1; i <= 10; i++) {
    System.out.print(i + " ");
}
{/JAVA_CONSOLE}

Malá násobilka

Teraz si vypíšeme malú násobilku (násobky čísel 1 až 10, vždy do desiatich). Stačí nám urobiť cyklus od 1 do 10 a premennú vždy násobiť daným číslom. Mohlo by to vyzerať 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á aplikácia
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 pekne, ale aj tak sme toho dosť napísali. Pokiaľ vám napadlo, že v podstate robíme 10x to isté a iba zvyšujeme číslo, ktorým násobíme, máte pravdu. Nič nám nebráni vložiť dva cykly do seba:

{JAVA_CONSOLE}
System.out.println("Multiplication with nested loops:");
for (int j = 1; j <= 10; j++) {
    for (int i = 1; i <= 10; i++) {
        System.out.print((i * j) + " ");
    }
    System.out.println();
}
{/JAVA_CONSOLE}

Pomerne zásadný rozdiel, však? Pochopiteľne nemôžeme použiť u oboch cyklov premennú i, pretože sú vložené do seba. Premenná j nadobúda vo vonkajšom cykle hodnoty 1 až 10. V každej iterácii (rozumejte priebehu) cyklu je potom spustený ďalší cyklus s premennou i. Ten je nám už známy, vypíše násobky, v tomto prípade násobíme premennú j. Po každom behu vnútorného cyklu je potrebné odriadkovať, to vykoná metóda System.out.println().

Mocnina čísla

Urobme si ešte jeden program, na ktorom si ukážeme prácu s vonkajšou premennou. Aplikácia bude vedieť spočítať mocninu s prirodzeným exponentom:

{JAVA_CONSOLE}
Scanner scanner = new Scanner(System.in, "Windows-1250");
System.out.println("Exponent calculator");
System.out.println("==========");
System.out.println("Enter the base: ");
int base = Integer.parseInt(scanner.nextLine());
System.out.println("Enter the exponent: ");
int exponent = Integer.parseInt(scanner.nextLine());

int result = 1;
for (int i = 0; i < exponent; i++) {
    result = result * base;
}

System.out.println("Result: " + result);
System.out.println("Thank you for using our exponent calculator");
{/JAVA_CONSOLE}

Asi všetci tušíme, ako funguje mocnina. Pre istotu pripomeniem, že napríklad 2³ = 2 * 2 * 2. Teda aⁿ spočítame tak, že si vytvoríme premennú s hodnotou 1. To je výsledok, ktorý by sme dostali pri nulovom exponente 2⁰ = 1. Pokiaľ bude exponent 0, cyklus sa nespustí. V opačnom prípade budeme našu premennú postupne v cykle násobiť n krát a výsledok si budeme postupne ukladať. Ak ste to nestihli, máme tu samozrejme lekciu s algoritmom výpočtu ľubovoľnej mocniny. Vidíme, že naša premenná result je v tele cyklu normálne prístupná. Pokiaľ si však nejakú premennú založíme v tele cyklu, po skončení cyklu zanikne a už nebude prístupná:

Konzolová aplikácia
Exponent calculator
==========
Enter the base:
2
Enter the exponent:
3
Result: 8
Thank you for using our exponent calculator

Už tušíme, ako sa cyklus for využíva. Zapamätajme si, že počet opakovaní je pevne daný.

Ukážka zacyklenia

Do premennej cyklu by sme nemali nijako zasahovať ani dosadzovať, program by sa mohol tzv. zacykliť. Skúsme si ešte posledný, odstrašujúci príklad:

{JAVA_CONSOLE}
// This code is wrong
for (int i = 1; i <= 10; i++) {
    i = 1;
}
{/JAVA_CONSOLE}

Au, vidíme, že program sa zasekol. Cyklus stále inkrementuje premennú i, ale tá sa vždy zníži na hodnotu 1. Nikdy teda nedosiahne hodnotu > 10, cyklus nikdy neskončí. Program zastavíme tlačidlom Stop pri okne konzoly. To je pre dnešnú lekciu všetko 🙂

V budúcej lekcii, Cyklus while v Jave, sa budeme ešte venovať cyklom. Naučíme sa používať while cyklus a vylepšíme našu kalkulačku.

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.