Tento díl je věnovám řídících příkazům, které větví či cyklí běh programu dle podmínek.
6.8.2004 10:00 | Petr Hatina | czytane 56989×
RELATED ARTICLES
KOMENTARZE
Řízení programu
Řízení programu obvykle neprobíhá jen v pořadí příkazů ve zdrojovém kódu,
ale často se větví či cyklí v řídících příkazech vyhodnocování podmínek.
Stanovení podmínek
Obvyklým typem testované podmínky je hodnota proměnné.
Můžeme testovat na :
int a=0;boolean ok;
if (a==0 ) ok=true; //shodu s hodnotou operátorem ==
if (a!=0 ) ok=true; // neshodu s hodnotou operátorem !=
if (a>0 ) ok=true; // zda je větší
if (a<=0 ) ok=true; // zda je menší
if (a>=0 ) ok=true; // zda je větší nebo rovno
if (a<=0 ) ok=true; // zda je menši nebo rovno
Lze testovat více podmínek dohromady pomocí logických operátorů
&&
(a, současně),
||
(nebo),
!
(negace).
if (a==0 && b>5 ) a=1; //pokud a je 0 a b>5
Podobně jako hodnoty proměnných můžeme testovat hodnoty vracené z metod objektů. Například u minule uvedeného Date lze testovat .
Date dat=new Date();
if ((dat.getDate()==13) )
System.out.println ("Je 13.teho");
Další oblast která by spadala do oblasti řízení programu je ošetřování chybových stavů, což se
ale v Javě řeší jinak, pomocí vyjímek, kterým budeme věnovat samostatnou kapitolu, a proto teď rovnou přejdeme k řídícím příkazům.
If
Nejčastějším příkazem pro řízení běhu programu dle podmínky je příkaz
if
.
Používá se ve formátech
if (podmínka) Příkaz;
,
nebo
if (podmínka) Příkaz; else JinyPříkaz;
V tomto případě se vykoná Příkaz při splnění podmínky, zatímco při nesplnění podmínky se vykoná JinýPříkaz, uvedený v klauzuli else.
Pokud je v případě splnění podmínky třeba vykonat více příkazů, uzavřou se jako blok do složených závorek.
int a=0; boolean splneno;
if (a==0) {splneno=true;a=1;}
Výraz ? :
Jako zkrácenou náhradu příkazu if pro přiřazení hodnoty lze použít výraz
? :
ve formátu
vracenáhodnota = podmínka ? hodnota1 : hodnota2
což značí, že při splnění podmínky je vrácena hodnota1 , při nesplnění je vrácena hodnota2
Příklad :
int a =0 ;boolean b;
b= a==0 ? true :false; //b je true
a=1;
b= a==0 ? true :false; //b je false
Cykly while a do - while
Cykly
do
a
do while
provádějí opakování části kódu dokud je plněna testovaná podmínka.
Formát prvního je while (podmínka ) příkaz;
, i když obvykle pracuje s celým blokem příkazů jako v tomto příkladu.
int i=10;
System.out.println("CountDown");
while (i >= 0)
{ System.out.println(""+i);
i--;
}
System.out.println("Boom");
Druhý příkaz ,
do - while
se liší tím že se podmínka vyhodnocuje
až
na konci bloku, čili blok se provede alespoň jednou.
int i=10;
do System.out.println(i) while(>=0);
for
Cyklus
for
se používá k opakování bloku kódu v zadaném, pevném počtu opakování.
Jeho obecný formát je
for (inicializace; podmínka ukončení;příkaz kroku) příkaz.
Inicializace se provádí před zahájením cyklu,
v každém průchodu se provádí test podmínky,
a po ukončení každého průchodu cyklem se provede příkaz kroku.
Ten by měl souviset s testovanou podmínkou,
obvykle jde o navýšení proměnné která počítá průchody cyklem.
Konkrétnější , jasnější a nejčastěji používaný formát vypadá takto :
for(int i =0; i < n; i++)
{blok příkazů} Což značí, opakuj blok příkazů n krát.
V Javě je zvykem počítat v cyklu ne od 1 do n, ale od 0 do n-1. Důvodem je to, že toto číslování používají striktně některé struktury Javy, jako jsou například pole.
//tento kod vytiskne ASCII Znaky od 30 do 127
for (char c=32;c < 128;c++)
System.out.println("ASCII znak "+ (int)c + " je " + c);
break
V některých případech je vhodné přerušit a ukončit předčasně zpracování cyklu (do, while i for) ještě před provedením všech průchodů. K tomu se používá příkaz break, kterým lze z cyklu vystoupit, (obvykle na základě další, vnitřní podmínky ).
int hledcislo=13;boolean nalez=false;
for (int i =1;i<20;i++)
{ if (i==hledcislo) {System.out.println(i);nalez=true;break;}}
if (nalez) System.out.println("hledane cislo nalezeno");
else
System.out.println("hledane cislo nenalezeno");
V praktickém případě bychom samozřejmě hledané číslo nezadávali jako konstantu.
continue
Podobný příkazu break je continue, liší se tím, že z cyklu nevystupuje, pouze přeskočí ještě nevykonané příkazy do konce cyklu, a přejde zpět na začátek cyklu, a pokračuje další iterací.
Příklad vytiskne čísla dělitelná 17
int i=0;
while(++i<52)
{
if (i % 17 !=0 ) continue;
System.out.println(i);
}
Návěští
V případě složitějšího kódu ve kterém dochází ke vnořování více cyklů do sebe, lze využít možnost přesunutí řízení do vyšších cyklů na určené místo,
označené návěštím. ve tvaru jmenonavesti: (za názvem musí být dvojtečka). Tento název se pak využije v příkazech break a continue.
Obecný případ vypadá takto
navesti1:
for (int i=1;i<1000;i++)
{
do
{ //vnitřní cyklus
if (k==0) continue navesti1;
//dalsi prikazy
}
while(j<50)
}
Nicméně tento příkaz až nebezpečně připomíná nestrukturovaný příkaz goto, známý z jiných jazyků. (kdo se nebojí goto, ten se nebojí ničeho, říkalo se v osmdesátých letech). Je vhodné psát cykly jednodušší.
switch
Příkaz switch je formou podmínkového příkazu, který větví zpracování na základě konkrétní hodnoty:
switch(proměnná)
case hodnota1: příkaz1;break;
case hodnota2: příkaz1;break;
case hodnota3: příkaz1;break;
default: příkaz;
Pokud testovaná proměnná obsahuje hodnotu1 , provede se příkaz1 , při hodnotě 2 příkaz 2, atd . Samozřejmě, místo jednoho příkazu může být uvedený celý blok, a každá větev musí být ukončena příkazem
break
.
Tedy obecně vzato nemusí, pokud se to hodí (a není to jen omylem), bez ukončení příkazem break dojde ke zpracování příkazů další větve.
Pokud je uvedena klauzule default, příkaz za ní se provede pokud proměnná obsahuje jinou hodnotu než
uvedenou v předešlých hodnotách. Jen upřesněním že proměnná musí být celočíselná.
Doplnění k předešlému dílu
V diskusi k předešlému k dílu se objevil dotaz čtenáře ohledně zápisu čísel pro proměnné typu float.
Pokud se ve zdrojovém kódu napevno zapisují hodnoty do proměnných,
lze stanovit jejich typ přidáním znaku za číslem: (lze použít velká i malá písmena)
long l=10000L;
float f=1.02F;
double d= 3.14111111D;
}