6. díl - Cykly v Javě

Java Základní konstrukce Cykly v Javě

Minule jsme si v tutoriálu vysvětlili podmínky . Nyní přejdeme k cyklům, po dnešním tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni tvořit rozumné aplikace.

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.

FOR cyklus

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ě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 tím 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 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é o 1.

Pojďme si udělat jednoduchý příklad, 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:

System.out.println("Knock");
System.out.println("Knock");
System.out.println("Knock");
System.out.println("Penny!");

My ale už nic nemusíme otrocky opisovat:

for (int i=0; i < 3; i++)
{
        System.out.println("Knock");
}
System.out.println("Penny!");
Ukázka cyklů v Javě – 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 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. 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.

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

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í printf(), můžeme místo ní použít pouze print(), která na rozdíl od println() po vypsání neodřádkuje:

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

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:

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) + " ");
}
Malá násobilka pomocí for cyklu v Javě

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 2 cykly do sebe:

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();
}

Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme použít u obou cyklů 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á System.out.prin­tln().

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 libovolnou mocninu libovolného čísla:

Scanner sc = new Scanner(System.in, "Windows-1250");

System.out.println("Mocninátor");
System.out.println("==========");
System.out.println("Zadejte základ mocniny: ");
int a = Integer.parseInt(sc.nextLine());
System.out.println("Zadejte exponent: ");
int n = Integer.parseInt(sc.nextLine());

int vysledek = a;
for (int i = 0; i < (n - 1); i++)
{
        vysledek = vysledek * a;
}

System.out.printf("Výsledek: " + vysledek);
System.out.println("Děkuji za použití mocninátoru");

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 n-1 krát vynásobíme číslo a číslem a. Výsledek si samozřejmě musíme ukládat do proměnné. Zpočátku bude mít hodnotu a a postupně se bude v cyklu pronásobovat. Pokud jste to nestihli, máme tu samozřejmě článek 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á.

Výpočet libovolné mocniny v Javě

Už tušíme, k čemu se for cyklus využívá. Zapamatujme si, že je počet opakování pevně daný. 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:

// tento kód je špatně
for (int i = 1; i <= 10; i++)
{
        i = 1;
}

Au, vidíme, že program se zasekl. Cyklus stále inkrementuje proměnnou i, ale ta se vždy sníží na 1. Nikdy tedy nedosáhne hodnoty > 10, cyklus nikdy neskončí. Program zastavíme tlačítkem Stop u okna konzole.

While cyklus

While cyklus funguje jinak, jednoduše opakuje příkazy v bloku dokud platí podmínka. Syntaxe cyklu je následující:

while (podminka)
{
        // příkazy
}

Pokud vás napadá, že lze přes while cyklus udělat i FOR cyklus, máte pravdu :) FOR je vlastně speciální případ while cyklu. While se ale používá na trochu jiné věci, často máme v jeho podmínce např. metodu vracející logickou hodnotu true/false. Původní příklad z for cyklu bychom udělali následovně pomocí while:

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

To ale není ideální použití while cyklu. Vezmeme si naši kalkulačku z minulých lekcí a opět ji trochu vylepšíme, konkrétně o možnost zadat více příkladů. Program tedy hned neskončí, ale zeptá se uživatele, zda si přeje spočítat další příklad. Připomeňme si původní verzi kódu (je to ta verze se switchem, ale klidně použijte i tu bez něj, záleží na vás):

System.out.println("Vítejte v kalkulačce");
System.out.println("Zadejte první číslo:");
float a = Float.parseFloat(sc.nextLine());
System.out.println("Zadejte druhé číslo:");
float b = Float.parseFloat(sc.nextLine());
System.out.println("Zvolte si operaci:");
System.out.println("1 - sčítání");
System.out.println("2 - odčítání");
System.out.println("3 - násobení");
System.out.println("4 - dělení");
int volba = Integer.parseInt(sc.nextLine());
float vysledek = 0;
switch (volba)
{
        case 1:
                vysledek = a + b;
        break;
        case 2:
                vysledek = a - b;
        break;
        case 3:
                vysledek = a * b;
        break;
        case 4:
                vysledek = a / b;
        break;
}
if ((volba > 0) && (volba < 5))
{
        System.out.println("Výsledek: " + vysledek);
}
else
{
        System.out.println("Neplatná volba");
}
System.out.println("Děkuji za použití kalkulačky.");

Nyní vložíme téměř celý kód do while cyklu. Naší podmínkou bude, že uživatel zadá "ano", budeme tedy kontrolovat obsah proměnné pokracovat. Zpočátku bude tato proměnná nastavena na "ano", aby se program vůbec spustil, poté do ní necháme načíst volbu uživatele:

Scanner sc = new Scanner(System.in, "Windows-1250");

System.out.println("Vítejte v kalkulačce");
String pokracovat = "ano";
while (pokracovat.equals("ano"))
{
        System.out.println("Zadejte první číslo:");
        float a = Float.parseFloat(sc.nextLine());
        System.out.println("Zadejte druhé číslo:");
        float b = Float.parseFloat(sc.nextLine());
        System.out.println("Zvolte si operaci:");
        System.out.println("1 - sčítání");
        System.out.println("2 - odčítání");
        System.out.println("3 - násobení");
        System.out.println("4 - dělení");
        int volba = Integer.parseInt(sc.nextLine());
        float vysledek = 0;
        switch (volba)
        {
                case 1:
                                vysledek = a + b;
                break;
                case 2:
                                vysledek = a - b;
                break;
                case 3:
                                vysledek = a * b;
                break;
                case 4:
                                vysledek = a / b;
                break;
        }
        if ((volba > 0) && (volba < 5))
        {
                System.out.println("Výsledek: " + vysledek);
        }
        else
        {
                System.out.println("Neplatná volba");
        }
        System.out.println("Přejete si zadat další příklad? [ano/ne]");
        pokracovat = sc.nextLine();
}
System.out.println("Děkuji za použití kalkulačky.");

Všimněte si, že Stringy porovnáváme pomocí metody equals(), nikoli pomocí operátoru ==! Je to dáno tím, že String je referenční datový typ. Podmínka ("Text" == "Text") je špatně, musíme psát ("Text".equal­s("Text")). V kapitole o objektově orientovaném programování pochopíme proč.

Jednoduchá kalkulačka v Javě s možností opakovat výpočet pomocí while cyklu

Naši aplikaci lze nyní používat vícekrát a je již téměř hotová. Příště si ukážeme práci s poli.

Již toho umíme docela dost, začíná to být zábava, že? :)


 

Stáhnout

Staženo 556x (52.04 kB)
Aplikace je včetně zdrojových kódů v jazyce java

 

  Aktivity (2)

Článek pro vás napsal David Čápka
Avatar
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.

Jak se ti líbí článek?
Celkem (31 hlasů) :
4.967744.967744.967744.967744.96774


 


Miniatura
Předchozí článek
Cvičení k 5. lekci Javy
Miniatura
Všechny články v sekci
Základní konstrukce jazyka Java
Miniatura
Následující článek
Cvičení k 6. lekci Javy

 

 

Komentáře
Zobrazit starší komentáře (42)

Avatar
Miroslav Melzer:

Děkuju za snahu pomoct, ale zatim mě to moc nenakoplo...

 
Odpovědět 2. října 16:49
Avatar
Odpovídá na Miroslav Melzer
Miroslav Melzer:

Mělo by to fungovat takhle:

System.out.println("zadej kurs");
     float a =Float.parseFloat(sc.nextLine());

     System.out.printf("celkový kurs je zatím %.2f ",a);
     System.out.println("zadej další");

      float b =Float.parseFloat(sc.nextLine());
      System.out.printf("celkový kurs je zatím %.2f ",a*b);
      System.out.println("zadej další");

      float c =Float.parseFloat(sc.nextLine());
      System.out.printf("celkový kurs je zatím %.2f ",a*b*c);
      System.out.println("zadej další");
         }
run:
zadej kurs
1.58
celkový kurs je zatím 1,58 zadej další
1.26
celkový kurs je zatím 1,99 zadej další
1.8
celkový kurs je zatím 3,58 zadej další
BUILD SUCCESSFUL (total time: 18 seconds)

Těch případů (kursů) by tam mělo jít vložit kolik bude uživatel chtít.
Ale nedokážu to napasovat do nějakýho toho cyklu.
 
Odpovědět 3. října 15:24
Avatar
pocitac770
Redaktor
Avatar
Odpovídá na Miroslav Melzer
pocitac770:

Otázka. Potřebuješ na každou hodnotu novou proměnnou? Vždyť ji použiješ jen jednou, pokaždé použiješ její hodnotu vynásobenou nějakým číslem, potom výsledek vynásobený dalším číslem, atd atd. A k tvému původnímu problému, proměnné, které jsou uvnitř cyklu mají trvání pouze po dobu jednoho opakování, pak se načtou znovu, ale ty, co jsou mimo něj si poslední uloženou hodnotu pamatují, ať jsi cyklů udělal kolik chceš. Popřemýšlej nad tím ;)

 
Odpovědět 3. října 16:30
Avatar
Marian Benčat
Redaktor
Avatar
Odpovídá na pocitac770
Marian Benčat:

to by byla samozřejmě pravda, kdyby to byla pravda... :-) Java nerozlišuje z hlediska bytecodu jestli je proměnná uvnitř cyklu, nebo vně.. pořád generuje stejný bytecode.. Programátorská poučka však je, že by se proměnná měla definovat co nejblíže použití. Takže správně je naopak dávat proměnnou dovnitř cyklu.

" premature optimization is the root of all evil (or at least most of it) in programming." -Donal Knuth

Editováno 3. října 16:48
 
Odpovědět 3. října 16:46
Avatar
pocitac770
Redaktor
Avatar
Odpovídá na Marian Benčat
pocitac770:

Ano, ale on se snaží najít způsob, jak něco udělat, a jestli sis toho nevšiml, tak já se mu snažím napovědět jak, sám řekl, že nechce přímé řešení

Editováno 3. října 17:18
 
Odpovědět 3. října 17:17
Avatar
Odpovídá na Marian Benčat
Miroslav Bejlek:

Pokud definuji proměnnou uvnitř cyklu, tak po opuštění cyklu ztratím údaje té hodnoty. Jak mohu tuto proměnnou použít o opuštění cyklu?

 
Odpovědět 3. října 17:26
Avatar
Odpovídá na pocitac770
Miroslav Melzer:

Ne, nechápu to co s tim mam udělat....

String dalsi = "a";
   while(dalsi.equals("a"))
   {
    System.out.println("zadej kurs");
    float a = Float.parseFloat(sc.nextLine());
    System.out.println("Celkový kurs je zatím " + a);
    System.out.println("další ? a/n");

    dalsi = sc.nextLine();
    dalsi= dalsi.toLowerCase();
   }

Tyhle věci se mi tam musí opakovat :zadej kurs +celkovy je....+ další a/n
musí tam bejt i ten vstup uživatele, jestli teda cyklus s dalším během načte novou zadanou hodnotu....
Ale jak mam dát jinou proměnnou mimo cyklus, když musí pracovat s tou proměnnou "a" ?
A jak potom změnim ten -Celkový kurs je ..."a" ?

 
Odpovědět 4. října 19:17
Avatar
pocitac770
Redaktor
Avatar
Odpovídá na Miroslav Melzer
pocitac770:

K proměnným vně cyklu můžeš přistupovat i zevnitř (ovšem ne naopak), vždyť jsi to i udělal s proměnnou "dalsi"

 
Odpovědět 4. října 19:22
Avatar
Miroslav Melzer:

Teď mě napadlo, že ten první běh nemusí bejt v cyklu a trochu to napůl funguje:

System.out.println("zadej kurs");
   float a = Float.parseFloat(sc.nextLine());
   System.out.println("Celkový kurs je zatím " + a);

  String dalsi = "a";
  while(dalsi.equals("a"))
  {
   System.out.println("zadej kurs");
   float b = Float.parseFloat(sc.nextLine());
   System.out.println("Celkový kurs je zatím " + a*b);
   System.out.println("další ? a/n");

   dalsi = sc.nextLine();
   dalsi= dalsi.toLowerCase();
  }
run:
zadej kurs
1.5
Celkový kurs je zatím 1.5
zadej kurs
1.8
Celkový kurs je zatím 2.6999998
další ? a/n
a
zadej kurs
2
Celkový kurs je zatím 3.0
další ? a/n
n
BUILD SUCCESSFUL (total time: 30 seconds)

akorát tam zůstává těch 1.5 ze začátku......což je to o čem jsi mluvil...proměnná mimo cyklus......

 
Odpovědět 4. října 19:27
Avatar
pocitac770
Redaktor
Avatar
 
Odpovědět 4. října 19:32
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 52. Zobrazit vše