Obsah
Na pravé straně je výraz vracející hodnotu primitivního typu
Na levé straně je proměnná téhož nebo širšího typu jako přiřazovaná hodnota
Při zužujícím přiřazení se také provede konverze, ale může dojít ke ztrátě informace
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é:
vytvořilo nový objekt typu Person
( new Person()
)
Nyní můžeme odkaz na tentýž vytvořený objekt
znovu přiřadit - do z2
:
Proměnné z1
a z2
ukazují
nyní na stejný objekt typu osoba!!!
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.
Buďto automaticky posledním příkazem v těle metody
nebo explicitně příkazem return
návratováhodnota
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
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;
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í.
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:
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
do { příkaz1; příkaz2; příkaz3; ... } while (podmínka);
Dokud není z klávesnice načtena požadovaná hodnota:
String vstup = ""; float number; boolean isOK; // create a reader from standard input BufferedReader in = new BufferReader(new InputStream(System.in)); // until a valid number is given, try to read it do { String input = in.readLine(); try { number = Float.parseFloat(input); isOK = true; } catch (NumberFormatException nfe) { isOK = false; } } while(!isOK); System.out.println("We've got the number " + number);
obecnější než for v Pascalu, podobně jako v C/C++
De-facto jde o rozšíření while, lze jím snadno nahradit
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; ... }
for
cyklů (1)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 -
for
cyklů (2)Někteří autoři nedoporučují psát deklaraci řídicí proměnné přímo do závorek cyklu
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
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.
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!!!
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.
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"“
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
.