Programovßnφ v jazyce Java
Kurz programovßnφ v Jav∞ - 8. dφl
┌vodem | Kurz programovßnφ v Jav∞ | Kurz programovßnφ v Jav∞ pro mobilnφ telefony | Soubory ke sta₧enφ | Otßzky a odpov∞di
┌vod
Vφtßm vßs vÜechny u osmΘho dφlu serißlu o zaΦßtcφch programovßnφ v Jav∞. Minule jsem slφbil, ₧e podrobn∞ proberu p°φkazy break a continue. Tyto dva p°φkazy nßs Φekajφ jako prvnφ a nakonec jeÜt∞ p°φkaz return.
P°φkaz break
V minulΘm dφle jsme si ukßzali pou₧itφ break v p°φkazu switch. To je jeho jedno pou₧itφ, nap°.:
| P°φklad pou₧itφ break v p°φkazu switch | |
|---|---|
...
int i;
...
switch(i) {
case 0:
System.out.println("i se rovna nule");
break;
case 1:
System.out.println("i se rovna jedne");
break;
case 2:
System.out.println("i se rovna dvema");
break;
default:
System.out.println("i se nerovna 0, 1 ani 2");
}
i = 5;
...
|
|
V∞tec default je nepovinnß a stejn∞ tak p°φkaz break, kter² je takΘ nepovinn². Ale oba zlepÜujφ mo₧nosti p°φkazu switch. Kdybychom nep°idaly v∞tev default, nic by se nestalo kdyby se prom∞nnß i nerovnala 0, 1 nebo 2. A koneΦn∞ p°φkaz break v tomto p°φpad∞ d∞lß to, ₧e kdy₧ se na n∞j narazφ v n∞kterΘ v∞tvi, p°eskoΦφ se cel² p°φkaz switch a provßd∞nφ programu pokraΦuje za pravou slo₧enou zßvorkou ukonΦujφcφ p°φkaz switch. To znamenß, ₧e pokud by prom∞nnß i byla rovna jednΘ, prvnφ p°φkaz by byl vypsßnφ °et∞zce "i se rovnß jedne" pomocφ metody println(), dalÜφ p°φkaz break, kter² by ukonΦil cel² zbytek t∞la p°φkazu switch, to znamenß, ₧e dalÜφ p°φkaz by byl prvnφ p°φkaz nßsledujφcφ za slo₧enou zßvorkou, to je i = 5.
DalÜφ jeho pou₧itφ je v cyklech, vÜechny jsme probφrali minule. A jsou to while, do-while a for. Pou₧itφ p°φkazu break v t∞le cyklu ukonΦφ cel² cyklus a stejn∞ jako u switch pokraΦuje za pravou slo₧enou zßvorkou, kterß ukonΦuje cel² cyklus. Pro nßzornost mal² p°φklad:
| P°φklad pou₧itφ break v cyklu | |
|---|---|
...
int i = 10;
for (;;i ++) {
if (i == 15) {
break;
}
...
}
...
|
|
Tento cyklus by se provßd∞l nekoneΦn∞ dlouho, pokud by neobsahoval podmφnkov² p°φkaz if, kter² testuje velikost prom∞nnΘ i a pokud je rovna 15, ukonΦφ cel² cyklus pomocφ p°φkazu break. Tam kde se v cyklu narazφ na p°φkaz break, se takΘ cyklus ukonΦφ, tzn. ₧e se u₧ ₧ßdnΘ p°φkazy v t∞l∞ cyklu le₧φcφ za p°φkazem break neprovedou, ale p°eskoΦφ a cyklus se ukonΦφ.
P°φkaz continue
P°φkaz continue se takΘ pou₧φvß v cyklech. To znamenß, ₧e ho m∙₧eme pou₧φt ve vÜech cyklech, kterΘ jsme minule probφrali, pou₧φvß se stejn∞ jako p°φkaz break. Kdy₧ se na p°φkaz continue narazφ p°i provßd∞nφ programu v t∞le cyklu, p°eskoΦφ se zbytek t∞la cyklu le₧φcφ za p°φkazem continue, stejn∞ jako u p°φkazu break, ale cyklus se neukonΦφ, pouze se p°ejde do dalÜφ smyΦky cyklu.
| P°φklad pou₧itφ continue v cyklu | |
|---|---|
...
for (int i = 0; i < 5; i ++) {
if (i == 3) {
continue;
}
System.out.println("i se rovna " + i);
}
...
|
|
Tento p°φklad dob°e ukazuje funkci p°φkazu continue. T∞lo cyklu se provede p∞tkrßt, ale do konzole se vypφÜφ pouze 4 zprßvy. Je to zp∙sobeno p°φkazem continue, proto₧e pokud je prom∞nnß i rovna t°em, provede se p°φkaz continue a ten p°eskoΦφ zbytek t∞la cyklu vΦetn∞ metody println() a pokraΦuje se v dalÜφ iteraci. P°φ dalÜφm pr∙chodu t∞la cyklu nenφ podmφnka platnß, proto se p°φkaz continue neprovede a normßln∞ se zavolß metoda println().
Pou₧itφ nßv∞Ütφ u p°φkaz∙ break a continue
Oba p°φkazy, break a continue, existujφ ve verzi s nßv∞Ütφm. P°φkaz break s nßv∞Ütφm lze pou₧φt v situacφch, kde je mnoho cykl∙ vno°en²ch do sebe a nap°φklad pot°ebujeme z nejvnit°n∞jÜφho cyklu ukonΦit najednou vÜechny obklopujφcφ cykly. P°φkaz break s nßv∞Üφm to zvlßdne, ale pod podmφnkou, kterou jsem napsal, ₧e m∙₧e ukonΦit pouze cykly obklopujφcφ tento p°φkaz. P°φkaz break lze pou₧φt jen v cyklu, ale vyskoΦit m∙₧ete i z blok∙, kterΘ si sami oznaΦφte nßv∞Ütφm. P°φkaz continue s nßv∞Ütφm funguje stejn∞ jako obyΦejn² p°φkaz continue, ale p°i pou₧itφ nßv∞Ütφ m∙₧ete pokraΦovat v jakΘmkoli obklopujφcφm cyklu.
| P°φklad pou₧itφ break s nßv∞Ütφm 1 | |
|---|---|
...
for (int i = 0; i < 3; i ++) {
vnejsi: {
stredni: {
vnitrni: {
System.out.println("i se rovna " + i);
if (i == 0) break vnejsi;
if (i == 1) break stredni;
if (i == 2) break vnitrni;
}
System.out.println("vnitrni");
}
System.out.println("stredni");
}
System.out.println("vnejsi");
}
...
|
|
V p°φklad∞ v²Üe je ukßzano pou₧itφ break s nßv∞Ütφm. Ukazuje jak definovat vlastnφ pojmenovanΘ bloky, kterΘ lze pou₧φt p°i "vyskoΦenφ".
| P°φklad pou₧itφ break s nßv∞Ütφm 2 | |
|---|---|
...
prvni: for (int i = 0; i < 3; i ++) {
druhy: for (int j = 0; j < 3; j ++) {
if (j == 2) {
break prvni;
}
}
}
...
|
|
Zde je ukßzßno jak ukonΦit vφce cykl∙ najednou, pokud je hodnota prom∞nnΘ j rovna dv∞ma, p°φkaz break ukonΦφ oba cykly.
| P°φklad pou₧itφ continue s nßv∞Ütφm | |
|---|---|
...
System.out.println("zacatek");
prvni: for (int i = 0; i < 3; i ++) {
druhy: for (int j = 0; j < 3; j ++) {
treti: for (int k = 0; k < 3; k ++) {
if (k == 2) {
continue druhy;
}
System.out.println("treti");
}
if (j == 2) {
continue prvni;
}
System.out.println("druhy");
}
System.out.println("prvni");
}
System.out.println("konec");
...
|
|
Tento p°φklad ukazuje pou₧itφ p°φkazu continue s nßv∞Ütφm.
U t∞chto p°φklad∙ nenφ moc co vysv∞tlovat, majφ ukßzat, jak² je zßpis nßv∞Ütφ, ale k p°esnΘmu pochopenφ p°φkaz∙ si musφ ka₧d² sßm zaexperimentovat, tyto p°φklady zde takΘ slou₧φ jako zaΦßtek vaÜich experiment∙.
P°φkaz return
Tento p°φkaz se pou₧φvß pro nßvrat z metody. Metody jsme zatφm neprobφrali, ale n∞kter²ch vyu₧φvßme u₧ te∩, nap°φklad metoda println(). Hlavn∞ si myslφm, ₧e pokud probφrßme p°φkazy, tak sem p°φkaz return pat°φ. Nechci te∩ moc zabφhat do podrobnostφ o metodßch, o t∞ch a₧ n∞kdy p°φÜt∞. Ale v naÜich pogramech deklarujeme jednu metodu poka₧dΘ a to metodu main(). Jist∞ jste se vÜimli, ₧e za nßzvem metody pφÜi kulatΘ zßvorky. Je to proto, aby se odliÜili nßzvy prom∞nn²ch a nßzvy metod. Deklarace metody se zklßdß z identifikßtoru p°φstupu, dßle nßvratovΘho typu a nakonec nßzvu metody. JeÜt∞ jsou sice dalÜφ v∞ci, kterΘ lze do deklarace napsat, ale to nenφ pro nßs zatφm d∙le₧itΘ. JednotlivΘ v∞ci si vysv∞tlφme na metod∞ main(), kterou musφ obsahovat ka₧d² nßÜ program.
| Metoda main() | |
|---|---|
public static void main(String[] args) {
}
|
|
Prvnφ slovo u tΘto deklarace je public (ve°ejnß metoda), existujφ 4 typy p°φstupu public (ve°ejnß), implicitnφ, protected (chrßn∞nß) a private (neve°ejnß). public znamenß, ₧e ji lze volat odkudkoli a k²mkoli. DalÜφm slovem je static, metody jsou bu∩ statickΘ (pφÜe se v deklaraci slovo static), nebo nestatickΘ (nepφÜe se v deklaraci static ani nic jinΘho). T°etφm slovem je void. ZnaΦφ nßvratov² typ, v tomto p°φpad∞ void (prßzdn²), to znamenß, ₧e metoda nevracφ ₧ßdnou hodnotu. Metody mohou vracet vÜechny jednoduchΘ datovΘ typy i objektovΘ datovΘ typy. Poslednφm slovem je nßzev metody. Elementy v kulat²ch zßvorkßch jsou argumenty metody a stejn∞ jako u deklarace prom∞nn²ch (prakticky je to deklarace) se pφÜe typ a nßzev prom∞nnΘ. Pokud mß metoda vφce argument∙, jednotlivΘ argumenty se odd∞lujφ Φarkou, metoda main() mß pouze jeden argument a to prom∞nou typu pole (jeÜt∞ jsme pole neprobφrali) objektov²ch typ∙ String. Toto pole obsahuje argumenty p°edanΘ p°i spuÜt∞nφ programu.
Ale vra¥me se k p°φkazu return. Nap°φklad metoda main() se provßdφ p°φkaz po p°φkazu od levΘ slo₧enΘ zßvorky a konΦφ pravou slo₧enou zßvorkou. Pokud chceme metodu ukonΦit metodu d°φve, ne₧ u pravΘ slo₧enΘ zßvorky pou₧ijeme p°φkaz return. Toto platφ ale pouze u metod, kterΘ nevracφ ₧ßdnou hodnotu. Pokud metoda hodnotu vracφ, musφme p°φkaz return pou₧φt v₧dy, ale za return musφme jeÜt∞ dopsat hodnotu, kterou mß vrßtit.
| P°φklad pou₧itφ return | |
|---|---|
...
int i;
...
public static void main(String[] args) {
System.out.println("prvni prikaz metody main()");
if (i == 10) {
return;
}
System.out.println("i neni rovno 10");
}
...
|
|
Myslφm, ₧e pou₧itφ p°φkazu return zde je ·pln∞ jasnΘ. Po zavolßnφ metody, volß se automaticky p°i startu programu, nebo jeÜt∞ jinak, ka₧d² program se zaΦφnß provßd∞t v metod∞ main (ne tak ·pln∞, nap°φklad u program∙ pro mobilnφ telefony metoda main() nenφ, ale zase je tam n∞jakß jinß metoda, kterß se volß jako prvnφ p°i spuÜt∞nφ programu). Prvnφm p°φkazem je volßnφ metody println() dßle je pou₧it p°φkaz if, kter² pokud mß hodnotu true, zavolß p°φkaz return. P°φkaz return ukonΦφ provßd∞nφ metody (stejn∞ jako break u cykl∙) a vrßtφ volßnφ (v tomto p°φpad∞ ukonΦφ program).
Jak bude p°φkaz return vypadat, pokud mß metoda vrßtit n∞jakou hodnotu se m∙₧ete podφvat v nßsledujφcφm p°φkladu.
| P°φklad pou₧itφ return, kter² vracφ hodnotu | |
|---|---|
...
public static void main(String[] args) {
int a = 10;
int b = 5;
int vysledek = vynasobit(a, b);
System.out.println(vysledek);
}
public int vynasobit(int a, int b) {
return (a * b);
}
...
|
|
Necht∞l jsem sice zab²hat a₧ tak do podrobnostφ, ale pokud jste pochopili jak to funguje, je to pro vßs v²hoda, a pokud ne, v∙bec to nevadφ proto₧e metody se budou podrobn∞ probφrat pozd∞ji. Tento p°φklad m∞l ukßzat pou₧itφ p°φkazu return a to myslφm splnil. Metoda vynasobit() je deklarovßna jako public a nßvratov² typ je int, to znamenß, ₧e za p°φkazem return musφ b²t v²raz vracejφcφ hodnotu typu int. Obsahuje dva argumenty a a b. A v jejφm t∞le je pouze p°φkaz return, kter² vracφ hodnotu v²razu a * b. Samoz°ejm∞ je mo₧nΘ vracet hodnotu prom∞nnΘ, nebo p°φmo za return napsat hodnotu, kterou chcete vrßtit, nap°φklad return 10, vrßtφ hodnotu typu int s velikostφ 10.
Zßv∞r
Probrali jsme dva d∙le₧itΘ p°φkazy, kterΘ se pou₧φvßjφ v cyklech, break a continue. Vysv∞tlili jsme si i p°φkaz return.