Programovßnφ v jazyce Java
Kurz programovßnφ v Jav∞ - 7. 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φtejte u 7. pokraΦovßnφ kurzu programovßnφ v Jav∞. V tomto dφle probereme n∞kterΘ p°φkazy.
P°φkazy
P°φkazy slou₧φ k °φzenφ chodu programu. Mohou se provßd∞t jeden za druh²m, jak jsou napsßny, ale takΘ se mohou n∞kterΘ p°eskoΦit, tomu se °φkß v∞tvenφ programu.
Slo₧en² p°φkaz
Slo₧en² p°φkaz, nebo takΘ blok, je vφce p°φkaz∙ tvß°φcφch se jako jeden p°φkaz. ZaΦßtek slo₧enΘho p°φkazu tvo°φ levß slo₧enß zßvorka { a konec pravß slo₧enß zßvorka }. Mezi t∞mito dv∞ma zßvorkami je t∞lo bloku. P°φkazy se odd∞lujφ st°ednφkem a pro p°ehlednost je lepÜφ psßt ka₧d² p°φkaz na sv∙j °ßdek. Blok m∙₧e obsahovat vφce p°φkaz∙, jeden p°φkaz, nebo takΘ ₧ßdn² p°φkaz.
Bloky lze takΘ do sebe vno°ovat, tzn. ₧e v jednom bloku bude blok dalÜφ. Ve vno°enΘm bloku lze pou₧φvat prom∞nnΘ, kterΘ jsou deklarovßny v obklopujφcφm bloku, ale naopak ne. Pokud tedy deklarujete ve vno°enΘm bloku n∞jakou prom∞nnou, nem∙₧ete ji pou₧φt jinde ne₧ v tom bloku, kde jste ji deklarovali.
| P°φklad slo₧enΘho p°φkazu - bloku | |
|---|---|
...
{ // zacatek slozeneho prikazu (bloku)
System.out.println("prvni prikaz ve slozenem prikazu");
int i = 10; // druhy prikaz
{ // zacatek vnitrniho bloku
System.out.println("vnitrni blok"); // prvni vnitrni prikaz
int a = 5; // druhy vnitrni prikaz
} // konec vnitrniho bloku
int b = i + 20; // treti prikaz
// a = 12; nelze kvuli tomu, ze platnost promenne a uz zkoncila
...
} // konec slozeneho prikazu
...
|
|
V tomto dφle budeme slo₧enΘ p°φkazy Φasto pou₧φvat.
Prßzdn² p°φkaz
Mo₧nß to znφ podivn∞, ale opravdu se pou₧φvß a docela Φasto. Je to p°φkaz, co ned∞la v∙bec nic. Jeho pou₧φtφ je nutnΘ v p°φpad∞, ₧e je n∞kde po₧adovßn p°φkaz, ale my nechceme nic d∞lat. Prßzdn² p°φkaz lze zapsat bu∩ st°ednφkem ;, nebo slo₧en²mi zßvorkami {}.
| P°φklad pou₧itφ prßzdnΘho p°φkazu | |
|---|---|
...
int i = 0
while ((nejakaMetoda(i ++)) == 20) {
}
// nebo
while ((nejakaMetoda(i ++)) == 20)
;
...
|
|
Tento p°φklad nenφ nic moc, ale pro demonstraci prßzdnΘho p°φkazu staΦφ (a o to p°eci jde :-)).
P°φkaz if
Prvnφ p°φkaz umo₧≥ujφcφ v∞tvenφ programu, kter² probereme je p°φkaz if. Pou₧φvß se tam, kde chceme provΘst n∞co jen za urΦitΘ podmφnky. Jeho nejjednoduÜÜφ formu jsme pou₧ili v minulΘm dφle. Jeho dalÜφ mo₧nΘ podoby naleznete v nßsledujφcφch tabulkßch.
| if | |
|---|---|
| if ( v²raz ) p°φkaz ; | |
| nebo | |
| if ( v²raz ) { | |
| prikaz1; | |
| prikaz2; | |
| prikaz3; | |
| ... | |
| } | |
V²raz (podmφnka) musφ b²t typu boolean nap°.: 5 > 3. Pokud vyhodnocenφ v²razu vrßtφ true je p°φkaz spln∞n, pokud ale vrßtφ false, p°φkaz se neprovede. U druhΘ mo₧nosti se p°i spln∞nφ v²razu provede cel² slo₧en² p°φkaz, tzn. ₧e se provedou vÜechny p°φkazy ve slo₧en²ch zßvorkßch.
N∞kdy je pot°eba provΘst p°φkaz prßv∞ p°i nespln∞nφ podmφnky a na to tu je dalÜφ forma p°φkazu if a to if - else.
| if - else | |
|---|---|
| if ( v²raz ) p°φkaz1 ; | |
| else p°φkaz2 ; | |
| nebo | |
| if ( v²raz ) { | |
| prikaz1; | |
| prikaz2; | |
| ... | |
| } | |
| else { | |
| prikaz5; | |
| prikaz6; | |
| ... | |
| } | |
P°i spl∞nφ podmφnky je proveden p°φkaz1 a p°i nespln∞nφ p°φkaz2. Druhß mo₧nost ukazuje to samΘ, ale s pou₧itφm slo₧en²ch p°φkaz∙.
P°φkazy if - else lze do sebe vno°ovat, ukß₧eme si to na p°φkladu:
| if - else | |
|---|---|
...
int a = 3;
if (a == 0) {
prikaz;
} else if (a == 1) {
prikaz2;
} else if (a == 2) {
if (b == 3) {
prikaz3;
}
} else {
prikaz4;
}
...
|
|
Myslφm, ₧e fungovßnφ vno°en²ch podmφnek je z p°φkladu jasnΘ. Kdyby ne, tak to funguje tak, ₧e za else je oΦekßvßn p°φkaz a prßv∞ tam se vlo₧φ dalÜφ p°φkaz if. V tomto p°φpad∞ by se provedl prikaz4. U t°etφ podmφnky je jeÜt∞ vlo₧en jeden p°φkaz if, pro ukßzku vÜech mo₧nostφ.
Odsazovßnφ jednotliv²ch p°φkaz∙ a od°ßdkovßnφ nemusφte d∞lat p°esn∞ podle m∞, proto₧e to zßle₧φ na ka₧dΘm jak mu to vyhovuje. Samoz°ejm∞ existujφ urΦitΘ konvence, kterΘ je nutnΘ dodr₧ovat, ale i tak je v nich mnoho mφsta na vlastnφ styl odsazovßnφ a od°ßdkovßnφ. Nap°φklad zßvorky nemusφte pou₧φvat pokud pou₧ijete jen jeden p°φkaz, ale jß je v₧dy pou₧φvßm kv∙li p°ehlednosti, tak₧e zßle₧φ na vßs co si vyberete, jß t°eba preferuji p°ehlednost zdrojovΘho k≤du.
P°φkaz switch
DalÜφ p°φkaz pro v∞tvenφ programu je switch. ╚esky by se takΘ dal nazvat p°epφnaΦ. Jedna z mo₧n²ch forem je ukßzßna v nßsledujφcφ tabulce.
| switch | |
|---|---|
| switch ( v²raz ) { | |
| case konstanta : p°φkaz; | |
| case konstanta : p°φkaz; | |
| case konstanta : p°φkaz; | |
| ... | |
| default: p°φkaz; // default je nepovin² | |
| } | |
V²raz m∙₧e b²t pouze typu char, byte, short nebo int. V²sledek v²razu se porovnßvß s konstantami. Pokud se narazφ na odpovφdajφcφ konstantu, provedou se vÜechny v²razy za dvojteΦkou a₧ do konce p°φkazu switch. Toto °eÜenφ nemusφ vyhovovat ka₧dΘmu a tak se pou₧φvß p°φkaz break k p°eskoΦenφ vÜech dalÜφch p°φkaz∙. P°φkaz break je vysv∞tlen dßle, ale my si jeho pou₧φtφ ukß₧eme na p°φkladu. Pokud se odpovφdajφcφ konstanta nenajde, provede se p°φkaz za default:. Default se pou₧φvat nemusφ, ale pak se neprovede ₧ßdn² p°φkaz, pokud se nenajde odpovφdajφcφ konstanta.
| P°φklad pou₧φtφ p°φkazu switch | |
|---|---|
...
int a = 5;
int b = 7;
int c = 0;
switch (a * b) {
case 30 :
c = 1;
break;
case 35 :
c = 2;
break;
case 40 :
c = 3;
break;
default: c = 10;
}
...
|
|
Pro jeho ·plnΘ pochopenφ bude nejlepÜφ, kdy₧ si ho ka₧d² po°ßdn∞ prozkouÜφ vÜemi mo₧n²mi zp∙soby. P°φkaz break je zde pou₧it proto, aby se dalÜφ zbylΘ p°φkazy uvedenΘ za break p°eskoΦili. N∞kdy je zase pot°eba aby se p°ovedli vÜechny dalÜφ p°φkazy, tak se break neuvede. Zde mß v²raz hodnotu 35, nalezne se odpovφdajφcφ konstanta a za dvojteΦkou je nalezen p°φkaz: c = 2; a break. Kdyby tam p°φkaz break nebyl provedly by se i p°φkazy c = 3; a c = 10;(Jen tehdy pokud by nebyly pou₧ity p°φkazy break nikde).
P°φkaz while
P°φkaz while se °adφ to tzv. cykl∙. Cyklus proto, ₧e se jeho t∞lo opakuje tak dlouho, dokud platφ podmφnka (v²raz). V²raz, jako obvykle musφ b²t typu boolean, to znamenß, ₧e v²sledek v²razu musφ b²t true nebo false.
| while | |
|---|---|
| while ( v²raz ) p°φkaz | |
Je dobrΘ ho pou₧φvat v situacφch, kdy je pot°eba opakovat p°φkazy, ale nenφ znßmo kolikrßt, p°ed zaΦßtkem cyklu, nap°φklad naΦφtßnφ dat ze souboru. V∞tÜinou nidky nevφme, kolik dan² soubor bude mφt dat, tak₧e se data naΦφtajφ tak dlouho, dokud n∞jakß jsou. My si po vysv∞tlenφ cyklu do-while ukß₧eme p°φklad pro naΦφtßnφ dat z konzole pomocφ while i do-while.
P°φkaz do-while
Tento cyklus je podobn² obyΦejnΘmu cyklu while. Nejd°φve provede p°φkaz a pak teprve kontroluje v²raz, kter² kdy₧ mß hodnotu true, znovu provede p°φkaz. Nap°φklad by se dal vyu₧φt pro Φtenφ znak∙ po znaku z konzole, jde to provΘst i pomocφ pou₧itφ obyΦejnΘho cyklu while. Oba p°φklady si ukß₧eme.
| P°φklad pou₧itφ do - while | |
|---|---|
import java.io.*;
public class Cteni1 {
public static void main(String[] args) throws Exception {
char znak;
StringBuffer sb = new StringBuffer(20);
InputStreamReader isr = new InputStreamReader(System.in);
System.out.println("Start programu (pro konec zadejte 'q')");
do {
znak = (char) isr.read();
if (znak == '\n') {
System.out.println("Zadali jste: " + sb);
sb.delete(0, sb.length());
} else {
sb.append(znak);
}
} while (znak != 'q');
System.out.println("Konec programu");
}
}
|
|
| P°φklad pou₧itφ while | |
|---|---|
import java.io.*;
public class Cteni2 {
public static void main(String[] args) throws Exception {
char znak;
StringBuffer sb = new StringBuffer(20);
InputStreamReader isr = new InputStreamReader(System.in);
System.out.println("Start programu (pro konec zadejte 'q')");
while ((znak = (char) isr.read()) != 'q') {
if (znak == '\n') {
System.out.println("Zadali jste: " + sb);
sb.delete(0, sb.length());
} else {
sb.append(znak);
}
}
System.out.println("Konec programu");
}
}
|
|
Toto jsou zdrojovΘ k≤dy program∙, kterΘ fungujφ ·pln∞ stejn∞, ale jeden pou₧φvß cyklus do-while a druh² while. V∞ci kterΘ dosud nebyly probrßny, budou urΦit∞ probrßny v nßsledujφch dφlech. P°φkaz import se pou₧φvß proto, aby se nemuseli psßt celΘ nßzvy t°φd i balφk∙ ve kter²ch jsou. Balφky jsme jeÜt∞ neprobφrali, tak₧e n∞kdy p°φÜt∞ je urΦit∞ probereme, zatφm to berte tak, ₧e to musφ b²t. Pou₧ili jsme objekt t°φdy StringBuffer, ten takΘ bude vysv∞tlen pozd∞ji. Je to objekt, kter² se pou₧φvß pro °et∞zce, stejn∞ jako String, je to zde pou₧ito kv∙li lepÜφmu v²konu aplikace (i kdy₧ nßm je te∩ jedno jak je aplikace rychlß). T°φda InputStreamReader se pou₧φvß pro Φtenφ znak∙. System.in je statick² objekt, kter² standardn∞ uchovßvß odkaz na vstupnφ konzoli. Metoda read() objektu InputStreamReader naΦφtß jeden znak z konzole. Asi je vßm z toho plno v∞cφ nejasn²ch, ale to nevadφ, proto₧e tohle nebyl p°φklad pro nauΦenφ Φtenφ dat z konzole, ale pro ukß₧ku dvou cykl∙, kterΘ jsme se v tomto dφle nauΦili.
P°φkaz for
Nejvφce pou₧φvan² cyklus, kter² nesmφ chyb∞t v ₧ßdnΘm jazyku, je cyklus for, kter² ani v Jav∞ nechybφ. Standardn∞ se pou₧φvß, tak, ₧e se deklaruje a inicializuje °φdφcφ prom∞nnß pro tento cyklus. Dßle se uvede podmφnka. A poslednφ v∞cφ je iterace °φdφcφ prom∞nnΘ.
| for | |
|---|---|
| for (inicializace; v²raz; zm∞na inicializovanΘ prom∞nnΘ ) p°φkaz | |
| nap°φklad: | |
| for (int i = 0; i < 10; i ++) System.out.println("neco vypis"); | |
Zajφmavostφ na tomto cyklu je, ₧e vÜechny parametry v zßvorkßch jsou nepovinnΘ. Ukß₧eme vÜechny druhy pou₧φtφ, s parametry i bez v nßsledujφcφm tabulce.
| Mo₧nosti cyklu for | |
|---|---|
...
for (int i = 0; i < 10; i ++) {
System.out.prinln("jedna moznost");
}
...
int i = 0;
for ( ; i < 10; i ++) {
System.out.println("dalsi moznost");
}
...
int i = 0;
for ( ; ; i ++) {
System.out.println("tento cyklus by se provadel nekonecne dlouho bez break");
if ( i > 10) {
break;
}
}
...
int i = 0;
for ( ; ; System.out.println("dalsi moznost")) {
if ( i > 10) {
break;
}
i ++;
}
...
int i = 0;
for ( ; ; ;) {
System.out.println("dalsi moznost");
if ( i > 10) {
break;
}
i ++;
}
|
|
Tyto mo₧nosti tu sice jsou, ale nejlepÜφ (doporuΦovanß) a nejp°ehledn∞jÜφ je mo₧nost prvnφ.
P°φkaz break a continue
P°φkazy break a continue by zaslou₧ili hlubÜφ v²klad, a tak si je nechßme na p°φÜt∞. Dnes si pouze °ekneme, ₧e p°φkaz break, kter² jsme pou₧φvali v naÜich p°φkladech p°eskoΦφ t∞lo p°φkazu a pokraΦuje za nφm. P°φkaz continue se pou₧φvß v cyklech a p°eskoΦφ zbytek t∞la p°φlazu, ale pokraΦuje dalÜφm cyklem. Podrobn∞, ale a₧ p°φÜt∞.
Zßv∞r
V dneÜnφm dφle jsme probrali r∙znΘ druhy p°φkaz∙. Slo₧enΘ p°φkazy, neboli bloky, "rozhodovacφ" p°φkazy a cykly. V p°φÜtφm dφle se m∙₧ete t∞Üit na dalÜφ p°φkazy a n∞jak² v∞tÜφ program vyu₧φvajφcφ vÜechny p°φkazy, kterΘ jsme se nauΦili. Nashledanou u dalÜφch dφl∙.