Specializovan² t²denφk o v²poΦetnφ technice
o Internetu
(CW 46/97)

---

Programovßnφ v jazyce Java

David ètrupl

V∞tvenφ a cykly

I p°φkazy v∞tvenφ a cykl∙ jsou svojφ syntaxφ velice podobnΘ jazyku C. NejjednoduÜÜφ v∞tvenφ zajiÜ¥uje p°φkaz if:

if (podmφnka) {
// p°φkazy provedenΘ p°i spln∞nφ podmφnky
} else {
// p°φkazy provedenΘ p°i nespln∞nφ podmφnky
}

V podmφnce v∞tÜinou s ·sp∞chem pou₧ijeme porovnßnφ:

if (a == 10 ) { .... // test na rovnost
if (a > 10 ) { .... // test na nerovnost

P°i porovnßvßnφ je t°eba dßvat pozor na to, porovnßvßme-li kompatibilnφ typy. Nem∙₧eme nap°. porovnßvat referenci na objekt se zßkladnφm typem.

Pokud chceme n∞jakou Φinnost opakovat, pou₧ijeme jeden z cykl∙. V Jav∞ existujφ dv∞ varianty while cyklu. Prvnφ mß podmφnku na zaΦßtku:

while (podm) {
p°φkazy
}

a druhß varianta na konci:

do {
p°φkazy
} while (podm);

Oba cykly provßd∞jφ p°φkazy uvedenΘ v t∞le cyklu tak dlouho, dokud je uvedenß podmφnka pravdivß. Rozdφl mezi t∞mito dv∞ma variantami je pouze v tom, ₧e v prvnφm p°φpad∞ se podmφnka vyhodnotφ p°ed provedenφm t∞la cyklu, zatφmco v druhΘm p°φpad∞ se vyhodnotφ a₧ po provedenφ p°φkaz∙ v t∞le cyklu. Podmφnka musφ b²t v²raz, kter² se vyhodnotφ na hodnotu typu boolean. Tj. typickΘ je pou₧itφ n∞kterΘho z booleovsk²ch operßtor∙ (==, !=, <, >, >=, <=), podobn∞ jako v p°φpad∞ p°φkazu if.

╚asto pou₧φvan²m druhem cyklu je tzv. for cyklus:

for (inicializace; podmφnka; aktualizace) {
p°φkazy
}

Tento zßpis mß tΘm∞° stejn² v²znam jako posloupnost:

inicializace;
while (podmφnka) {
p°φkazy;
aktualizace;
}

KlasickΘ pou₧itφ for cyklu je pro provßd∞nφ Φinnostφ s p°edem znßm²m poΦtem opakovßnφ. V∞tÜinou se pou₧ije zßpis podobn² nßsledujφcφmu:

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

Tento cyklus bude proveden 10krßt. Prom∞nnß deklarovanß v inicializaΦnφ Φßsti se naz²vß °φdicφ prom∞nnß cyklu. P°i pou₧itφ zde uvedenΘho zßpisu je rozsah jejφ platnosti omezen na cyklus. Poslednφm z v∞tvφcφch p°φkaz∙ je p°φkaz op∞t znßm² z jazyka C -- switch.

TypickΘ pou₧itφ p°φkazu switch je nßsledujφcφ:

switch (v²raz) {
case 0 : p°φkaz
break;
case 1 : p°φkaz
break;
...
default : p°φkaz
break;
}

Tento p°φkaz probφhß tak, ₧e po vyhodnocenφ v²razu se provede skok podle zφskanΘ hodnoty na n∞kterou v∞tev case. Pokud hodnota v²razu nenφ uvedena v ₧ßdnΘ case v∞tvi, m∙₧e provßd∞nφ skoΦit na v∞tev default (pokud je v∞tev default uvedena). P°φkazy break jsou stejn∞ jako v jazyce C pot°eba na ukonΦenφ p°φsluÜnΘ v∞tve -- pokud by blok za case nebyl ukonΦen klφΦov²m slovem break, pokraΦovalo by provßd∞nφ nßsledujφcφmi p°φkazy.

P°φkaz break m∙₧e b²t pou₧it k ukonΦenφ provßd∞nφ libovolnΘho cyklu. Pokud jsou cykly v sob∞ vno°eny, ukonΦφ provßd∞nφ nejvnit°n∞jÜφho z nich. Pokud chceme ukonΦit nikoliv nejvnit°n∞jÜφ cyklus, m∙₧eme jej oznaΦit nßv∞Ütφm, kterΘ lze potom uvΘst za p°φkazem break:

vnejsi:for (i=0; i<10; i++) {
for (j=0; j<10; j++) {
...
if (podm) { break vnejsi; }
// ukonΦφ provßd∞nφ obou cykl∙
}
}

Nßv∞Ütφm mohou b²t oznaΦeny pouze cykly a bloky switch -- nelze jej pou₧φt u libovolnΘho p°φkazu. Pou₧itφ nßv∞Ütφ na jinΘm mφst∞ ne₧ u cykl∙ nemß smysl, proto₧e v Jav∞ p°φkaz goto neexistuje!

Podobn²m p°φkazem jako p°φkaz break je p°φkaz continue, kter² zp∙sobφ skok na novou iteraci cyklu. I u n∞ho m∙₧e b²t uvedeno nßv∞Ütφ. Poslednφm zp∙sobem, jak ukonΦit provßd∞nφ cyklu, je pou₧φt uvnit° n∞ho p°φkaz return pro nßvrat z metody.

Prom∞nnΘ a rozsahy platnosti

Ka₧dß prom∞nnß a metoda mß p°esn∞ urΦeno, na kterΘm mφst∞ v programu ji m∙₧eme pou₧φt -- tj. mß definovßn sv∙j rozsah platnosti. NejjednoduÜÜφ je urΦenφ rozsahu platnosti u lokßlnφch prom∞nn²ch. Lokßlnφ prom∞nnß je viditelnß od svΘ deklarace do ukonΦenφ bloku, ve kterΘm se tato deklarace nachßzφ:

int k = 10;
if (k < 20) {
int j = 10;
// tady je mo₧nΘ pou₧φvat j, k
}
// zde je mo₧nΘ pou₧φvat k, ale ne j

Prom∞nnΘ deklarovanΘ jako vlastnosti objekt∙ v definici t°φd jsou v₧dy viditelnΘ z k≤du metod danΘ t°φdy. O tom, zda bude n∞jakß vlastnost nebo metoda p°φstupnß z vn∞jÜφho k≤du (z metod nepat°φcφch stejnΘ t°φd∞), rozhoduje modifikßtor uveden² p°ed deklaracφ prom∞nnΘ nebo metody. Modifikßtor m∙₧e b²t jedno z klφΦov²ch slov:

public -- prom∞nnß nebo metoda je viditelnß vÜude, kde je povoleno pou₧φt danou t°φdu

private -- prom∞nnß nebo metoda je viditelnß pouze uvnit° t°φdy

protected -- prom∞nnß nebo metoda je viditelnß v danΘ t°φd∞ a ve vÜech jejφch potomcφch

bez uvedenφ klφΦovΘho slova -- prom∞nnß nebo metoda je viditelnß v aktußlnφm balφku

P°φklad:

class MojeTrida {
public int poΦet;
protected void nastavPocet(int naKolik) {
poΦet = naKolik;
}
private soukroma;
}

Jak je vid∞t z uvedenΘho p°φkladu, pφÜe se modifikßtor p°φstupu v₧dy p°ed typ deklarovanΘ prom∞nnΘ. V²znam modifikßtor∙ je stejn² v p°φpad∞ prom∞nn²ch i metod.

StatickΘ prom∞nnΘ a metody

VÜechny prom∞nnΘ a metody, o kter²ch jsme doposud mluvili, byly tzv. instanΦnφ prom∞nnΘ a metody. Znamenalo to, ₧e s ka₧d²m vytvo°enφm novΘho objektu danΘ t°φdy se naalokovalo mφsto a vytvo°ily se novΘ kopie deklarovan²ch prom∞nn²ch. To mß logick² smysl, proto₧e instanΦnφ prom∞nnß je souΦßstφ definice objektu -- vytvo°φme-li nov² objekt, musφ se mu vytvo°it i novΘ vlastnosti.

V Jav∞ m∙₧eme pou₧φt jeÜt∞ jeden druh prom∞nn²ch -- tzv. statickΘ (t°φdovΘ) prom∞nnΘ. Tyto prom∞nnΘ jsou takΘ souΦßstφ definice t°φdy, ale jsou oznaΦeny klφΦov²m slovem static. Rozdφl oproti "normßlnφm" prom∞nn²m je ten, ₧e statickß prom∞nnß existuje pouze jednou pro celou t°φdu (proto se jφ takΘ n∞kdy °φkß t°φdovß prom∞nnß). Tyto prom∞nnΘ jsou dobrΘ pro udr₧ovßnφ globßlnφch informacφ o danΘ t°φd∞, nap°. m∙₧eme sledovat, kolik objekt∙ danΘ t°φdy mßme vytvo°eno. S existencφ statick²ch prom∞nn²ch je ·zce svßzßna i existence statick²ch metod. Tyto metody se podobn∞ jako statickΘ prom∞nnΘ vztahujφ k celΘ t°φd∞, a mohou tedy pou₧φvat pouze statickΘ prom∞nnΘ danΘ t°φdy (a samoz°ejm∞ i lokßlnφ prom∞nnΘ deklarovanΘ ve svΘm t∞le). Ukßzkou statickΘ metody je definice metody main. P°i volßnφ statick²ch metod nemusφ (a v∞tÜinou ani nenφ) vytvo°en objekt danΘ t°φdy (p°i volßnφ metody main nemusφ b²t vytvo°en objekt t°φdy, ve kterΘ se metoda main nachßzφ).

Specißlnφm druhem statick²ch prom∞nn²ch jsou konstanty, kterΘ jsou uvedeny klφΦov²m slovem final. Pokud se p°ed deklaracφ prom∞nnΘ objevφ slovo final, znamenß to, ₧e hodnota tΘto prom∞nnΘ nesmφ b²t v pr∙b∞hu v²poΦtu zm∞n∞na. Typickß kombinace klφΦov²ch slov je tedy public static final:

public class MojeTrida {
public static final int MAX_PO╚ET = 100;
static final float PI = 3.14;
public static void main(String args[]) {
System.out.println("Pi je : " + PI);
}
}

Pokud jsou prom∞nnΘ (konstanty) deklarovßny s modifikßtorem public, m∙₧eme jejich hodnotu pou₧φt i vn∞ definice danΘ t°φdy. V tomto p°φpad∞ je mo₧nΘ pou₧φt p°ed jmΘnem prom∞nnΘ jmΘno t°φdy, ve kterΘ je tato prom∞nnß (statickß) deklarovßna:

...

int k = MojeTrida.PI;

Konstanty v∞tÜinou oznaΦujeme identifikßtorem, kter² je cel² napsßn velk²mi pφsmeny -- pro snazÜφ orientaci v programu.