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šie0
, pretože v programovaní všetko začína od nuly, nie od jednotky). Napr. tedaint i = 0
. Samozrejme si môžeme premennúi
vytvoriť niekde nad cyklom a už nemusíme písať slovíčkoint
, býva ale zvykom používať práveint 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 o1
.
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 23 = 2 * 2 * 2. Teda
an spočítame tak, že si vytvoríme premennú s
hodnotou 1
. To je výsledok, ktorý by sme dostali pri nulovom
exponente 20 = 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š.
Stiahnuť
Stiahnutím nasledujúceho súboru súhlasíš s licenčnými podmienkami
Stiahnuté 13x (5.28 kB)
Aplikácia je vrátane zdrojových kódov v jazyku Java