Ří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;
}