V Javě máme následující příkazy:

Operátor přiřazení:

Na pravé straně výraz vracející hodnotu primitivního typu

číslo, logická hodnotu, znak (ale ne např. řetězec)

Na levé straně proměnná téhož typu jako přiřazovaná hodnota nebo typu širšího

např. int lze přiřadit do long

Při zužujícím přiřazení se také provede konverze, ale může dojít ke ztrátě informace

např. int -> short

Přiřazením primitivní hodnoty se hodnota zduplikuje ("opíše") do proměnné na levé straně.

Konstrukci = lze použít i pro přiřazení do objektové proměnné:

Zivocich z1 = new Zivocich();

Co to udělalo?

Nyní můžeme odkaz na tentýž vytvořený objekt znovu přiřadit - do z2:

Zivocich z2 = z1;

Proměnné z1 a z2 ukazují nyní na stejný objekt typu živočich!!!

Proměnné objektového typu obsahují odkazy (reference) na objekty, ne objekty samotné!!!

Metoda objektu je vlastně procedura/funkce, která realizuje svou činnost primárně s proměnnými objektu.

Volání metody určitého objektu realizujeme:

identifikaceObjektu.názevMetody(skutečné parametry)

Návrat z metody se děje:

způsobí ukončení provádění těla metody a návrat, přičemž může být specifikována návratová hodnota

typ skutečné návratové hodnoty musí korespondovat s deklarovaným typem návratové hodnoty

Příkaz (neúplného) větvení if

if (logický výraz) příkaz

platí-li logický výraz (má hodnoty true), provede se příkaz

Příkaz úplného větvení if - else

if (logický výraz) 
   příkaz1 
else 
   příkaz2    

platí-li logický výraz (má hodnoty true), provede se příkaz1

neplatí-li, provede se příkaz2

Větev else se nemusí uvádět

Tělo cyklu se provádí tak dlouho, dokud platí podmínka

obdoba while v Pascalu

v těle cyklu je jeden jednoduchý příkaz ...

while (podmínka) 
   příkaz; 

... nebo příkaz složený

while (podmínka) { 
   příkaz1;
   příkaz2; 
   příkaz3; 
   ...
} 

Tělo cyklu se nemusí provést ani jednou - pokud už hned na začátku podmínka neplatí

Větvení, cykly: doporučuji vždy psát se složeným příkazem v těle (tj. se složenými závorkami)!!!

jinak hrozí, že se v těle větvení/cyklu z neopatrnosti při editaci objeví něco jiného, než chceme, např.:

while (i < a.length) 
   System.out.println(a[i]); i++; 

Provede v cyklu jen ten výpis, inkrementaci ne a program se zacyklí.

Pišme proto vždy takto:

while (i < a.length) {
    System.out.println(a[i]); i++; 
} 

Dokud nejsou přečteny všechny vstupní argumenty:

int i = 0;
while (i < args.length) { 
   "přečti argument args[i]" 
   i++;
}    

Dalším příkladem je použití while pro realizaci celočíselného dělení se zbytkem:

Příklad: Celočíselné dělení se zbytkem

Tělo se provádí dokud platí podmínka (vždy aspoň jednou)

obdoba repeat v Pascalu (podmínka je ovšem interpretována opačně)

Relativně málo používaný - je méně přehledný než while

Syntaxe:

do { 
   příkaz1; 
   příkaz2;
   příkaz3; 
   ...
} while (podmínka); 

Dokud není z klávesnice načtena požadovaná hodnota:

String vstup = ""; 
float cislo; 
boolean nacteno; // vytvoř reader ze standardního vstupu 
BufferedReader in = new BufferReader(new InputStream(System.in)); 
// dokud není zadáno číslo, čti
do { 
   vstup = in.readLine(); 
   try { 
      cislo = Float.parseFloat(vstup); 
      nacteno = true;
   } catch (NumberFormatException nfe) { 
      nacteno = false; 
   }
} while(!nacteno); 
System.out.println("Nacteno cislo "+cislo);

Příklad: Načítej, dokud není zadáno číslo

obecnější než for v Pascalu, podobně jako v C/C++

De-facto jde o rozšíření while, lze jím snadno nahradit

Syntaxe:

for(počáteční op.; vstupní podm.; příkaz po každém průch.) 
   příkaz;    

anebo (obvyklejší, bezpečnější)

for (počáteční op.; vstupní podm.; příkaz po každém průch.) { 
   příkaz1; 
   příkaz2; 
   příkaz3;
   ...
} 

Provedení určité sekvence určitý počet krát

for (int i = 0; i < 10; i++) { 
   System.out.println(i); 
} 

Vypíše na obrazovku deset řádků s čísly postupně 0 až 9

Používejte asymetrické intervaly (ostrá a neostrá nerovnost):

Vytvarujte se složitých příkazů v hlavičce (kulatých závorkách) for cyklu -

Někteří autoři nedoporučují psát deklaraci řídicí proměnné přímo do závorek cyklu

for (int i = 0; ...

ale rozepsat takto:

int i; 
for (i = 0; ...    

potom je proměnná i přístupná ("viditelná") i mimo cyklus - za cyklem, což se však ne vždy hodí.

Obdoba pascalského select - case - else

Větvení do více možností na základě ordinální hodnoty

Syntaxe:

switch(výraz) { 
   case hodnota1: prikaz1a; 
                  prikaz1b;
                  prikaz1c; 
                  ... 
                  break; 
   case hodnota2: prikaz2a; 
                  prikaz2b; 
                  ... 
                  break;
   default:       prikazDa; 
                  prikazDb; 
                  ...
} 

Je-li výraz roven některé z hodnot, provede se sekvence uvedená za příslušným case.

Sekvenci obvykle ukončujeme příkazem break, který předá řízení ("skočí") na první příkaz za ukončovací závorkou příkazu switch.

Příklad: Vícecestné větvení

Větvení if - else můžeme samozřejmě vnořovat do sebe:

if(podmínka_vnější) { 
   if(podmínka_vnitřní_1) { 
      ... 
   } else { 
      ... 
   } 
} else { 
   if(podmínka_vnitřní_2) { 
      ...
   } else { 
      ... 
   }
}    

Je možné "šetřit" a neuvádět složené závorky, v takovém případě se else vztahuje vždy k nejbližšímu neuzavřenému if, např. znovu předchozí příklad:

if(podmínka_vnější) 
   if(podmínka_vnitřní1) 
      ... 
   else // vztahuje se k nejbližšímu if 
        // s if (podmínka_vnitřní_1) 
      ... 
else // vztahuje se k prvnímu if, 
     // protože je v tuto chvíli 
     // nejbližší neuzavřené 
   if (podmínka_vnitřní_2) 
      ... 
   else // vztahuje se k if (podmínka_vnitřní_2) 
      ...   

Tak jako u cyklů - tento způsob zápisu nelze v žádném případě doporučit!!!

Příklad: Vnořené větvení

Někdy rozvíjíme pouze druhou (negativní) větev:

if (podmínka1) {
   ... 
} else if (podmínka2) { 
   ...
} else if (podmínka3) { 
   ...
} else { 
   ... 
}    

Neplatí-li podmínka1, testuje se podmínka2, neplatí-li, pak podmínka3...

neplatí-li žádná, provede se příkaz za posledním - samostatným - else.

Opět je dobré všude psát složené závorky!!!

Příklad: Řetězené if

Realizuje "násilné" ukončení průchodu cyklem nebo větvením switch

Syntaxe použití break v cyklu:

for (int i = 0; i < a.length; i++) { 
   if(a[i] == 0) { 
      break; // skoci se za konec cyklu 
   }
}
if (a[i] == 0) {
    System.out.println("Nasli jsme 0 na pozici "+i); 
} else {
    System.out.println("0 v poli neni"); 
} 

použití u switch jsme již viděli„Vícecestné větvení "switch - case - default"“

Používá se v těle cyklu.

Způsobí přeskočení zbylé části průchodu tělem cyklu

for (int i = 0; i < a.length; i++) { 
   if (a[i] == 5) 
      continue; 
   System.out.println(i); 
} 

Výše uvedený příklad vypíše čísla 1, 2, 3, 4, 6, 7, 8, 9, nevypíše hodnotu 5.

Příklad: Řízení průchodu cyklem pomocí "break" a "continue"

Umožní ještě jemnější řízení průchodu vnořenými cykly:

Příklad: Návěští