1. ÚVOD ZÁKLADY JAZYKA...

Transkript

1 Obsah 1. ÚVOD ZÁKLADY JAZYKA... 4 PROMĚNNÉ... 4 PRIMITIVNÍ DATOVÉ TYPY... 5 Deklarace proměnné promitivního typu...5 Konstanty... 6 Přetypování... 7 Přetečení... 7 VÝRAZY A OPERÁTORY... 8 Aritmetické operátory a příkaz přiřazení... 8 Relační operátory... 9 Logické operátory... 9 Bitové operátory Podmíněný výraz ZÁKLADNÍ KONSTRUKCE PROGRAMU Posloupnost Větvení Cykly Příkazy break a continue VOLÁNÍ METOD ŘETĚZCE (TŘÍDA STRING) KOMENTÁŘE TŘÍDY ZÁKLADNÍ POJMY OBJEKTOVÉHO PROGRAMOVÁNÍ DEKLARACE TŘÍDY V JAVĚ...22 Modifikátory tříd PROMĚNNÉ TŘÍD A INSTANCÍ Deklarace proměnných Práce s proměnnými METODY Modifikátory metod Typ návratové hodnoty Vstupní parametry metody Předávání hodnot parametrů Přetěžování metod Konstruktory VYTVOŘENÍ INSTANCE ZRUŠENÍ INSTANCE ROZHRANÍ POLE JEDNOROZMĚRNÉ POLE VÍCEROZMĚRNÁ POLE PARAMETRY VSTUPNÍ ŘÁDKY SOUHRNNÝ PŘÍKLAD VÝJIMKY DRUHY VÝJIMEK VYVOLÁNÍ VÝJIMKY ZPŮSOB OŠETŘENÍ VÝJIMKY VSTUPY A VÝSTUPY VSTUPNÍ PROUDY Čtení ze souboru Čtení z konzole VÝSTUPNÍ PROUDY Zápis do textového souboru TŘÍDA STRINGTOKENIZER DALŠÍ TŘÍDY A METODY PRO PRÁCI S PROUDY Čtení ze sítě Komprimace a dekomprimace souborů TŘÍDA FILE DYNAMICKÉ DATOVÉ STRUKTURY

2 Obsah KONTEJNERY VYTVOŘENÍ KONTEJNERU PROCHÁZENÍ KONTEJNERU - ITERÁTOR SOUHRNNÝ PŘÍKLAD GRAFICKÉ UŽIVATELSKÉ ROZHRANÍ PRVNÍ APLIKACE VKLÁDÁNÍ DALŠÍCH KOMPONENT OBSLUHA UDÁLOSTÍ ROZLOŽENÍ KOMPONENT V RÁMCI OKNA Rozložení BorderLayout Rozložení FlowLayout Rozložení GridLayout Další rozvržení Kombinování správců rozvržení NASTAVENÍ VLASTNOSTÍ KOMPONENT Třída Font Třída Color TLAČÍTKA A TEXTOVÉ POLE TEXTOVÁ OBLAST ZAŠKRTÁVACÍ POLÍČKA A PŘEPÍNAČE ROZBALOVACÍ SEZNAM MENU OKNA PRO OTEVÍRÁNÍ A UKLÁDÁNÍ SOUBORŮ INFORMAČNÍ OKNA KARTIČKY DALŠÍ KOMPONENTY GUI APPLETY TŘÍDY APPLET A JAPPLET TAG APPLET PRVNÍ JEDNODUCHÝ APPLET APPLET S PARAMETREM PŘÍLOHY PŘÍLOHA 1 JAVA SDK OD FIRMY SUN Vytvoření a spuštění programu, Programy obsažené v Java SDK od firmy SUN PŘÍLOHA 2 POPIS ORIGINÁLNÍ DOKUMENTACE JAVY OD FIRMY SUN PŘÍLOHA 3 - KONVENCE PRO PSANÍ PROGRAMŮ V JAVĚ Jména souborů Struktura zdrojového souboru Javy Zarovnávání, odsazování Komentáře Deklarace Příkazy Mezery Konvence pro pojmenovávání PŘÍLOHA 4 JAR VYTVÁŘENÍ A POUŽÍVÁNÍ ARCHIVŮ PŘÍLOHA 5 - KÓDOVÁNÍ ČESKÝCH ZNAKŮ V JAVĚ PŘÍLOHA 6 - SEZNAM TERMÍNŮ A ZKRATEK LITERATURA A ODKAZY Literatura Informace o Javě na Internetu Vývojová prostředí a nástroje pro Javu

3 Úvod 1. Úvod Java je objektově orientovaný programovací jazyk, navržený jako přenositelný mezi platformami jako je Windows, Linux, Solaris, atd. Často bývá považován za jazyk určený pouze pro Internet. V Javě lze samozřejmě programovat pro Internet, ale také v ní lze vytvářet aplikace, které pracují s databázemi nebo soubory a s WWW nemají nic společného. V Javě můžeme vytvářet tři základní druhy programů: - aplety - programy běžící v rámci WWW stránky na stanici klienta v prohlížeči - servlety - programy běžící na WWW serveru - aplikace - programy, které se spouštějí na stanici Aby byla zajištěna přenositelnost mezi platformami probíhá překlad a spuštění takto: - překladač Javy nepřekládá zdrojový text do proveditelného kódu, ale do pseudokódu přenositelného na různé platformy - na počítači, kde chceme program spustit, musí být nainstalována JVM (Java Virtual Machine) pro danou platformu. JVM pracuje jako interpret a provádí postupně akce zapsané v pseudokódu - jestliže se jedná o aplet, v HTML kódu WWW stránky je zapsáno, jaký soubor s pseudokódem je třeba spustit. Prohlížeče umějí tento kód interpretovat (záleží na použité verzi Javy, někdy je třeba doinstalovat příslušné rutiny) Java je poměrně novým programovacím jazykem, poprvé byla představena firmou Sun v roce Od té doby již vzniklo několik verzí, označovaných firmou Sun 1.0, 1.1, 1.2 a 1.3. Nejpodstatnější rozdíly jsou mezi verzemi 1.0 a 1.1, verze 1.2 přinesla především rozšíření knihoven. Java 1.2 bývá také označována jako Java2 (pozor Java 1.3 je také Java2 ne 3). V těchto skriptech se budeme zabývat především verzí 1.2 a vyšší. Pro práci s jazykem Java byly vytvořeny různé vývojové nástroje od různých firem. V našem kurzu budeme používat JDK (Java Development Kit) firmy Sun, který je volně dostupný ke stažení na Internetu na adrese JAVA.SUN.COM. Přehled dalších vývojových nástrojů naleznete v příloze těchto skript. Tato skripta jsou určena studentům kurzu IT_112 Úvod do programování v jazyce Java. Cílem těchto skript je tedy seznámit studenty s jazykem a ukázat jim práci s několika vybranými standardními třídami (API, Application Programming Interface, obsahuje těchto tříd více než tisíc), aby byli schopni vytvořit v Javě jednoduché aplikace. 3

4 Základy jazyka 2. Základy jazyka Napíšeme si první jednoduchý program v Javě, na kterém si vysvětlíme základy jazyka. Bude to program, který sečte dvě celá čísla a výsledek zobrazí na konzoli. public class PrvniProgram { public static void main(string[] args) { int scitanec1 = 5; int scitanec2 = 2; int soucet = scitanec1 + scitanec2; System.out.println("Muj prvni program "); System.out.println("Soucet je: " + soucet); Programovací jazyk Java rozlišuje malá a velká písmena. Hned od počátku je třeba si uvědomit, že je rozdíl, jestli napíšeme soucet nebo Soucet, v Javě se jedná o dva různé identifikátory. Java jako objektový jazyk používá téměř vždy objekty. Každý program je třídou a proto je v našem prográmku uvedeno public class PrvniProgram. Class je klíčové slovo Javy pro deklaraci třídy, PrvniProgram je jméno této třídy (identifikátor) a public modifikátor třídy, který označuje třídu jako veřejně dostupnou. Dále musíme dodržet pravidlo, že soubor, ve kterém bude zdrojový text uložen, se musí jmenovat stejně jako třída a mít koncovku.java. V našem případě se soubor jmenuje PrvniProgram.java. Pozor, je třeba rozlišovat velká a malá písmena i u jmen souborů, i když např. ve Windows se to zdá být zbytečné. Překladač kontroluje shodu názvu třídy s názvem souboru včetně malých a velkých písmen. Pokud má být program spustitelný, musí v něm definovaná třída obsahovat metodu main deklarovanou se všemi modifikátory uvedenými v programu (tj. public static). Jejich význam bude vysvětlen v následujících kapitolách. Dále náš program obsahuje blok příkazů, ve kterém je deklarace a použití proměnných (scitanec1, scitanec2, soucet) a spuštění metod. Proměnné Při své činnosti si program ukládá data do proměnných či skupin proměnných. Popis proměnné se skládají ze tří částí: jména proměnné (identifikátoru), datového typu (např. celé číslo) a vlastního obsahu (hodnot, v případě tříd a rozhraní jsou součástí obsahu i metody). Jméno proměnné (identifikátor) musí začínat písmenem, po něm mohou následovat další písmena nebo číslice, délka není omezena. Ve jméně proměnné může být i podtržítko _ a znak $ 1. 1 Znak $ není vhodné používat, neboť ho překladač používá při vytváření interních proměnných. 4

5 Základy jazyka Java je přísně typový jazyk, proto je vždy nutno uvést datový typ proměnné. Datové typy v Javě lze rozdělit do těchto skupin: primitivní typy: čísla (byte, short, int, long, float, double) znaky (char) logické hodnoty (boolean) referenční typy: třídy (class) rozhraní (interface) pole (array) Referenčním typům jsou věnovány samostatné kapitoly. Primitivní datové typy Java používá pro celočíselné proměnné čtyři datové typy: long, int, short a byte, pro reálná čísla dva typy: double a float, pro znaky typ char a pro logické proměnné typ boolean. Velikost, jakou zabírají v paměti, a rozsah, který jsou schopny obsáhnout, vidíme v následující tabulce. Název typu Velikost (v bytech) Rozsah Implicitní hodnota 2 long až int až short až byte až double 8 ± E+308 float 4 ± E char různých znaků \u0000 boolean 1 bit true nebo false false tabulka 1 Primitivní datové typy Deklarace proměnné promitivního typu Při zavedení nové proměnné je nutné deklarovat identifikátor a datový typ, volitelně lze zadat i počáteční hodnotu. Deklaraci primitivního datového typu lze obecně zapsat takto: datový_typ jméno_proměnné; 3 datový_typ jméno_proměnné = počáteční_hodnota; 2 Pouze pro proměnné třídy a instancí, neplatí v případě proměnných metod. 3 Součástí deklarace proměnných mohou být modifikátory (public, static, final atd.) jejichž význam bude popsán později. 5

6 Základy jazyka Pokud tedy v našem programu sčítáme celá čísla, musíme pro ně nejdříve deklarovat proměnné: int scitanec1; int scitanec2 = 10; Počáteční hodnota proměnné může být uvedena nejen hodnotou, ale i výrazem, např.: long delka_dne=24 * 60 * 60; Výraz, kterým se přiřazuje hodnota, se musí dát vyhodnotit v době překladu popř. v okamžiku spuštění programu. Pokud proměnné při deklaraci nepřiřadíme počáteční hodnotu, kompilátor ji sám přiřadí (viz tabulka č.1) bohužel se implicitní hodnota nepřiřazuje proměnným deklarovaným v rámci metod. Pokud počáteční hodnota bude mimo rozsah proměnné (např. byte b = 200), některé překladače přiřadí nesmyslnou hodnotu, některé ohlásí chybu. Konstanty Konstanty se používají nejen při deklaraci proměnných, ale i v rámci výrazů. Celá čísla se zapisují obdobným způsobem jako v běžném životě, např. 9876; zápis nesmí obsahovat mezery či jiné oddělovače (např. tisíců). Je-li prvním znakem nula, znamená to, že číslo zapisujeme v osmičkové soustavě, začíná-li zápis čísla prefixem 0x, jedná se o číslo v hexadecimální (šestnáctkové) soustavě. Následující tři proměnné obsahují stejnou počáteční hodnotu: int i = 10; int j = 012; int k = 0xa; Celočíselná konstanta je vždy typu int, pokud potřebujeme konstantu jiného celočíselného typu, je třeba uvést přetypování (viz dále). Reálná čísla se zapisují buď s desetinnou tečkou (např. 0.25, ) nebo se používá tzv. semilogaritmický zápis, kdy číslo 1.54 * 10 6 se zapíše ve tvaru 1.54e6. Reálné konstanty jsou vždy typu double. Každý znak je v jazyce Java uložen v kódování Unicode ve dvou bytech. Znaky se píší v jednoduchých uvozovkách, a to buď v defaultním kódu operačního systému (v českých Windows 9x/NT je to kódová stránka CP1250), kdy překladač sám zajistí převod na příslušný znak Unicode, nebo použijeme zápis \uxxxx, ve kterém místo XXXX uvedeme hexadecimální kód příslušného znaku. char c = č ; char d = \u12ab ; Logické hodnoty proměnné typu boolean mohou nabývat pouze dvou hodnot, true nebo false. V Javě lze vytvářet i pojmenované konstanty primitivních datových typů definují se stejně jako proměnné s počáteční hodnotou s tím, že se na začátku uvede klíčové slovo final: final long DELKA_DNE=24 * 60 * 60; 6

7 Základy jazyka Takto definovanou proměnnou nelze již dále změnit, hodnota se přiřazuje v okamžiku definice. Zda se hodnota přiřadí při překladu či až při běhu programu záleží na výrazu, který přiřazuje hodnotu a na schopnosti optimalizace překladačem. Následující konstanta (náhodné číslo) se přiřadí až při běhu: final int NAHODNE_CISLO = (int) (Math.random() * 20); Je dobrým zvykem ve jménech konstant používat velká písmena. Přetypování U celočíselné konstanty zapsané v programu se předpokládá datový typ int, u reálných konstant datový typ double. Například ve výrazu long vysledek = 10000*10000 se provede násobení konstant typu int a výsledek typu int se převede do proměnné typu long. Pokud chceme, aby byla konstanta jiného datového typu, je třeba zapsat ji s literálem. Literál pro long je L, pro float f a pro double d (lze používat malá i velká písmena). Tedy zapíšeme-li konstantu L 4 bude uložena jako long, zápis 10000f znamená, že číslo je uloženo jako reálné. Pokud se hodnota proměnné kratšího typu ukládá do proměnné delšího typu, provede Java převod automaticky (neexistuje nebezpečí ztráty informace). Například: int cislo1 = 12; long cislo2; cislo2 = cislo1; Pokud bychom ale potřebovali opačné přiřazení, je třeba provést explicitní přetypování a oznámit tak překladači, že případná ztráta informace nevadí, např.: float desetinnecislo1; double desetinnecislo2 = ; desetinnecislo1 = (float) desetinncislo2; Při operacích s číselnými proměnnými typu byte a short se tyto proměnné automaticky převádějí na typ int, tj. výsledek operace s dvěma těmito proměnnými je typu int. Při operaci s proměnnými/konstantami různě dlouhých typů je výsledek delšího typu, tj. výsledkem operace proměnných typu int a long je proměnná typu long, výsledkem operace typu int a double je proměnná typu double atd. Proměnná kratšího typu se převede na delší typ před provedením operace. Pokud trváme na uložení do kratšího typu, je nutné přetypovat výsledek operace: long cislo1 = 10000; int cislo2 = 100; int vysledek = (int) (cislo1 cislo2); Přetečení Pokud nastane situace, že informace, kterou do proměnné ukládáme, má větší hodnotu než je maximální hodnota typu, pak mluvíme o tzv. přetečení. Java neohlásí žádnou chybu, ale usekne přesahující část a program tak vyprodukuje špatný výsledek. Např. výsledkem operace * je číslo 4 U literálu je výjimečně jedno zda je písmeno malé nebo velké. Pro long je lepší používat velké L, malé l si lze splést s číslicí 1. 7

8 Základy jazyka typu int místo správného , neboť tento výsledek je mimo rozsah typu int. K získání správného výsledku je potřeba aspoň jeden z operátorů označit jako long, tj. operace by měla vypadat následovně: L * Doporučujeme používat proměnné typu long místo typu int a typ double místo typu float. Výrazy a operátory Aritmetické operátory a příkaz přiřazení Se základními matematickými operátory jsme se už seznámili. Java používá pro sčítání +, pro odčítání -, pro násobení *, pro dělení / a pro zbytek po celočíselném dělení %. U přetypování a přetečení jsme už hovořili o problémech, které mohou nastat při těchto operacích. S dalším problémem se setkáváme u dělení celých čísel. Pokud v programu použijeme tento výraz double vysledek = 9/2 bude v proměnné vysledek hodnota 4. Výsledkem dělení dvou celých čísel je opět celé číslo bez ohledu na typ proměnné, do které výsledek ukládáme. Proto je i zde třeba použít přetypování nebo literál u jednoho z operandů, např.: double vysledek = 9d/2 V případě proměnných je potřeba jeden z operandů přetypovat, např. pokud cislo1 a cislo2 jsou typu int, double vysledek = ((double) cislo1) / cislo2 5. Java používá řadu zkrácených zápisů některých operací, jsou uvedeny v následující tabulce. Operátor Příklad Význam operátoru += x += y x = x + y -= x -= y x = x - y /= x /= y x = x / y *= x *= y x = x * y %= x %= y x = x % y ++ x++ x = x x -- x-- --x x = x - 1 tabulka 2 Význam některých aritmetických operátorů Pro často se vyskytující operace - zvyšování nebo snižování hodnoty proměnné o jedničku lze v Javě použít i zkrácený zápis x++, ++x, x--, --x. Tyto operátory lze (bohužel 6 ) použít i na pravé straně 5 Výraz lze zapsat i ve tvaru double vysledek = (double) cislo1 / cislo2, ale zde je nejasné, zda se přetypování týká prvního operandu či výsledku (nutno znát, zda má větší prioritu přetypování či dělení). Zápis double vysledek = (double) (cislo1 / cislo2) je určitě chybně, neboť ten přetypovává až vlastní výsledek operace, která proběhne jako celočíselná. 6 U výrazů se obvykle předpokládá, že se při výpočtu nemění hodnoty proměnných použitých na pravé straně výrazu operátory ++ a -- toto pravidlo porušují, což může vést k obtížně odhalitelným chybám. 8

9 Základy jazyka výrazu, kdy se rozlišuje, zda použijeme ++ jako předponu nebo příponu. Pokud se operátor ++ zapíše jako předpona, nejprve se zvýší hodnota proměnné a pak se použije, pokud je ++ zapsán jako přípona, pracuje se ve výrazu s původní hodnotou a teprve poté je zvýšena. Vysvětlíme si to v následujících příkladech. int puvodni = 10; int nova = puvodni++; Proměnná puvodni je nyní rovna 11 a proměnná nova je rovna 10. int puvodni = 10; int nova = ++puvodni; Proměnná puvodni je nyní rovna 11 a proměnná nova je rovna také 11. Pro operátor - - platí stejná pravidla. Relační operátory Relační operátory se používají pro porovnání hodnot dvou číselných proměnných (pokud nejsou stejného typu, tak se převedou na delší typ), proměnných typu char a boolean. Výsledkem je vždy hodnota typu boolean, tj. buď pravda (true) nebo nepravda (false). Obvykle se používají v příkazu if a v příkazech cyklu jako podmínky 7. Přehled relačních operátorů je v následující tabulce (pozor, nelze zaměnit pořadí znaků v operátorech): tabulka 3 Relační operátory Logické operátory relační operátor význam == rovná se!= nerovná se < menší než > větší než <= menší nebo rovno >= větší nebo rovno Logické operátory slouží pro vyjádření vztahu mezi dvěmi proměnnými/výrazy typu boolean, tj. obvykle k vytváření složených podmínek. V Javě se používají operátory && (logická spojka AND) a (logická spojka OR). Dále lze použít unární operátor!, který označuje negaci NOT následujícího výrazu. Chceme-li například otestovat, jestli je proměnná i větší nebo rovna 10 a současně menší než 50 zapíšeme podmínku takto: (i >= 10) && (i < 50) Výsledkem je hodnota true nebo false. 7 V textu se používá pojem podmínka místo správnějšího pojmu výraz s výslednou hodnotou typu boolean. Pojem podmínka je sice méně přesný, avšak často v kontextu lépe pochopitelný. 9

10 Základy jazyka Bitové operátory Java umožňuje pracovat i s jednotlivými bity celočíselných hodnot. Vzhledem k jejich výjimečnému použití zde nejsou popsány, v případě potřeby je nastudujte z on-line dokumentace. Podmíněný výraz V Javě existuje ternární operátor?:, který slouží k vytvoření tzv. podmíněného výrazu, syntaxe je: podmínka? výraz1 : výraz2 Zapíšeme-li například tento podmíněný výraz: cislo1 < 5? cislo2++ : cislo2-- Hodnota proměnné cislo2 se zvýší o jedničku (provede se výraz1) pokud je hodnota proměnné cislo1 menší než 5 (podmínka je splněna). Pokud je hodnota proměnné cislo1 větší nebo rovna 5 (tedy podmínka není splněna), hodnota proměnné cislo2 se sníží (provede se vyraz2). Pokud se na zápis podmíněného výrazu podíváme, pochopíme, že z důvodu přehlednosti je výhodnější používat příkaz if (viz dále). Základní konstrukce programu Při popisu algoritmu používáme v podstatě tři základní struktury a to: posloupnost příkazů, rozhodování na základě nějaké podmínky (větvení), opakování činnosti na základě podmínky (cyklus). S cykly souvisí příkazy pro změnu průběhu cyklu. Posloupnost Posloupnost příkazů v Javě zapíšeme tak, že jednotlivé příkazy a deklarace oddělíme středníkem. int scitanec1 = 5; int scitanec2 = 2; int soucet = scitanec1 + scitanec2; Příkazy lze napsat i takto: int scitanec1 = 5; int scitanec2 = 2; int soucet = scitanec1 + scitanec2; ale vzhledem k nepřehlednosti doporučuji zapisovat na každý řádek jeden příkaz či deklaraci. Řadu po sobě jdoucích příkazů a deklarací můžeme (a v mnoha případech musíme) spojit do bloku pomocí složených závorek. { int scitanec1 =5; int scitanec2 = 2; int soucet = scitanec1 + scitanec2; Po složené závorce už neuvádíme středník. 10

11 Základy jazyka Větvení Pro větvení má Java dva příkazy: if a switch. Příkaz if má podmínku a jednu nebo dvě větve. Syntaxe příkazu if s jednou větví je následující: if (podmínka) příkaz; Příkaz se provede pouze v případě, že podmínka platí tj. byla vyhodnocena jako true. Pokud podmínka byla vyhodnocena jako false, neprovede se nic a příkaz if končí. Syntaxe příkazu if se dvěma větvemi: if (podmínka) příkaz1; else příkaz2; Pokud je podmínka vyhodnocena jako true provede se příkaz1, pokud jako false provede se příkaz2. Místo jednoho příkazu je možno uvést blok příkazů uzavřený do složených závorek. Následující program vygeneruje dvě náhodná celá čísla v rozsahu 1 až 10 a poté zjistí jejich rozdíl (všimněme si též, jak se zapisují komentáře v Javě). public class IfElse { public static void main (String [] args) { /* Generovní náhodného čísla. Metoda random() třídy Math * vrací číslo typu double z intervalu 0 až 1. Pokud tedy chceme * celé číslo od 1 do 10, musíme ho násobit 10 přičíst 1 a * pomocí přetypování na int "odseknout" desetinnou část. */ int cislo1 = (int) (Math.random() * ); System.out.println ("Cislo1=" + cislo1); int cislo2 = (int) (Math.random() * ); System.out.println ("Cislo2=" + cislo2); if (cislo1 > cislo2) { int rozdil = cislo1 - cislo2; System.out.println ("Cislo1 je vetsi o:" + rozdil); else { int rozdil = cislo2 - cislo1; System.out.println("Cislo2 je vetsi o:" + rozdil); ; //konec záporné větve i celého if Promyslete si, co se stane v případě, že se vygenerují dvě stejná čísla. 11

12 Základy jazyka Málo používaný příkaz switch na základě hodnoty výrazu provádí příslušnou větev příkazu (větví obvykle bývá několik). Výraz musí být typu char, byte, short nebo int. Syntaxe je následující: switch (výraz) { case konstanta1: příkaz1; break; case konstanta2: příkaz2; break; case konstanta3: příkaz3; break; case konstanta4: příkaz4; break; //... default: příkaz; ; V bloku může být několik příkazů začínajících klíčovým slovem case následovaným konstantou (tj. nelze zde uvést např. i > 5) a dvojtečkou. Jeden příkaz může začínat klíčovým slovem default následovaným dvojtečkou. Při provádění příkazu switch se nejprve vyhodnotí výraz a program přejde na větev case s odpovídající hodnotou nebo tuto hodnotu nenajde a přejde na větev default. Obvykle se každá větev ukončuje příkazem break, pokud jím však není větev ukončena, pokračuje se v provádění všech následujících větví, i když je u nich uvedena jiná hodnota než jakou má výraz (záleží na pořadí uvedení větví!). Postup provádění následujících dvou příkladů je tedy různý. Příklad1 switch ( i ) { case 1 : prikaz1; break; case 2 : prikaz2; break; default : prikaz3; tabulka 4 Porovnání příkazu switch s break a bez něj Příklad2 switch ( i ) { case 1 : prikaz1; case 2 : prikaz2; default : prikaz3; Hodnota proměnné i Provedené příkazy příklad1 Provedené příkazy příklad2 1 prikaz1 prikaz1 prikaz2 prikaz3 2 prikaz2 prikaz2 prikaz3 jiná hodnota prikaz3 prikaz3 tabulka 5 Výsledky porovnání dvou variant příkazu switch Cykly V Javě jsou definovány tři druhy cyklů. První z nich je cyklus while s následující syntaxí: while ( podmínka ) příkaz; 12

13 Základy jazyka Provádění příkazu začíná vždy testem podmínky. Pokud je podmínka splněna (má hodnotu true), provede se příkaz a znovu se přejde na test podmínky. Při nesplnění podmínky provádění cyklu končí. Pokud podmínka není na začátku splněna, neprovede se příkaz v cyklu while ani jednou. int i=1; while (i <= 10) { // příkazy i++; Nekonečný cyklus lze zapsat následovně: while (true) { // příkazy Druhým a nejméně používaným typem cyklu je cyklus do-while s následující syntaxí: do příkaz while ( podmínka ); Tento cyklus začíná provedením příkazu a až poté se testuje podmínka. Dle výsledku se provádí znovu příkaz (hodnota true podmínky) nebo se končí (hodnota false). V cyklu do while se příkaz provede vždy alespoň jednou. Posledním typem cyklu je cyklus for, který používáme tam, kde známe počet iterací. Syntaxe: for ( inicializace; podmínka; krok) příkaz; Inicializací určujeme tzv. řídící proměnnou cyklu a její vstupní hodnotu. Pokud je splněna podmínka, provede se příkaz a poté se provede operace s řídící proměnnou cyklu uvedená v části krok. Poté se opět přejde na vyhodnocení podmínky. V následujícím příkladě se provede cyklus 10x (příklad odpovídá příkladu u cyklu while): for (int i = 1; i <= 10; i++) { // příkazy Následující cyklus se provede 50x s tím, že řídící proměnná cyklu bude nabývat pouze sudých hodnot: for (int i = 2; i <= 100; i += 2) { // příkazy Příkaz for lze přepsat do příkazu while následujícím způsobem: inicializace; while ( podmínka ) { příkaz; krok; 13

14 Základy jazyka Příkazy break a continue Jazyk Java zná příkazy break a continue, které ovlivňují průběh zpracování příkazů v rámci cyklu (příkaz break se používá i v příkazu switch). Jestliže v těle cyklu použijeme break, výsledkem bude skok za konec tohoto cyklu. for (int i = 0; i <= 5; i++) { if (i == 3) break; System.out.println(i); System.out.println("Konec programu"); Tato část programu bude mít tento výstup: Konec programu Příkaz continue způsobí, že je přeskočen zbytek těla cyklu a znovu se testuje podmínka cyklu (v případě cyklu for se provede ještě krok řídící proměnné cyklu). Pokud ve výše uvedeném příkladu použijeme místo break příkaz continue, bude výstup vypadat takto: Konec programu Break i continue lze uvést s návěstím a pak dojde ke skoku na toto návěstí, tj. lze opustit i několik do sebe vnořených cyklů. Návěstí ukončené dvojtečkou se uvádí v programu před začátkem vnějšího cyklu. /* CyklusSNavestim.java * ukazkovy priklad na pouziti navesti v cyklu while */ public class CyklusSNavestim { public static void main (String args[ ]) { int i = 0; vnejsicyklus: //definice návěstí "vnejsi cyklus" while (true) { //nekonečný cyklus while i++; int j = 0; while (true) { // vnořený nekonečný while j++; System.out.println("i: " + i + " j: "+j); if (j > i) { System.out.println("continue na vnejsicyklus (j > i)"); continue vnejsicyklus; ; if (j > 2) { System.out.println("break z vnitrniho cyklu (j > 2)"); break; 14

15 Základy jazyka ; ; System.out.println ("konec vnitrniho cyklu"); if (i > 3) { System.out.println("break z vnejsiho cyklu (i >3)"); break; ; ; System.out.println("konec vnejsiho cyklu"); ; má následující výstup: i: 1 j: 1 i: 1 j: 2 continue na vnejsicyklus (j > i) i: 2 j: 1 i: 2 j: 2 i: 2 j: 3 continue na vnejsicyklus (j > i) i: 3 j: 1 i: 3 j: 2 i: 3 j: 3 break z vnitrniho cyklu (j > 2) konec vnitrniho cyklu i: 4 j: 1 i: 4 j: 2 i: 4 j: 3 break z vnitrniho cyklu (j > 2) konec vnitrniho cyklu break z vnejsiho cyklu cyklu (i > 3) konec vnejsiho cyklu Volání metod V textu jsme se již mnohokrát setkali s voláním metod. Jak zjistíme později, rozlišují se metody třídy (statické) a metody instance. Jestliže potřebujeme použít metodu třídy, voláme ji uvedením jména třídy, tečky, jména metody a v kulatých závorkách parametry (nebo prázdné závorky pokud je metoda bez parametrů). V dokumentaci poznáte metody třídy dle toho, že ve specifikaci mají uvedeno klíčové slovo static. Například třída java.lang.math poskytuje celou řadu metod třídy pro provádění různých matematických operací, některé z nich spolu s příklady jsou uvedeny v tabulce č.6 (podrobnější popis a přehled dalších je v on-line dokumentaci): 15

16 Základy jazyka Metoda Popis Přiklad static int abs (int a); vrátí absolutní hodnotu cislo2 = Math.abs(cislo1) static long abs (long a); static float abs (float a); static double abs (double a); parametru static long round (double a); vrací nejbližší celé číslo static int round (float a); static double sqrt (double a); výpočet druhé cislo2 = Math.sqrt(cislo1) static double cos (double a); static double sin (double a); static double tan (double a); static double pow (double a, double b); static double min (double a, double b); static float min (float a, float b); static int min (int a, int b); static long min (long a, long b); static double max (double a, double b); static float max (float a, float b); static int max (int a, int b); static long max (long a, long b); tabulka 6 Metody třídy Math odmocniny trigonometrické funkce umocňování, a b vrací menší z obou hodnot vrací větší z obou hodnot Jak je v tabulce vidět (např. na metodě min), je možné v jedné třídě definovat více metod stejného jména s různým počtem, pořadím nebo typem parametrů. Tomuto říkáme přetěžování (overloading) metod. O tom, která z nich bude v programu použita, rozhodne překladač podle použitých parametrů. Pokud je některá metoda definována jen pro typ double (jako např. sqrt) není nutno přetypovávat hodnoty kratších typů na double, toto přetypování proběhne automaticky (tj. pokud proměnná cislo je typu int mohu napsat přímo Math.sqrt (cislo)). Jinak je tomu u typů návratových hodnot. Když metoda vrací hodnotu typu double, mohu ji uložit buď do proměnné typu double nebo ji mohu přetypovat do kratších typů (např. float či long). Lze tedy napsat: double odmocnina = Math.sqrt(cislo); float odmocnina = (float) Math.sqrt(cislo); následující zápis je chybný: float odmocnina = Math.sqrt(cislo); // SPATNE Druhým typem metod jsou metody instance, jediný rozdíl při volání těchto metod je, že uvádíme jméno instance a ne jméno třídy. Pro nejjednodušší programy a pro ladění se velmi často používají metody System.out.print(String s) nebo System.out.println(String s), které jsou určené pro výpis textového řetězce na konzoli. V tomto volání je tečka použita dvakrát, protože třída System obsahuje proměnnou out, která odkazuje na instanci třídy PrintStream, a pro tuto instanci vyvoláváme metodu print případně println, která je metodou třídy PrintStream. 16

17 Základy jazyka Ve volání metod se můžeme setkat i s více tečkami. S výjimkou metod z tříd (či třídy) z balíku (package) java.lang, je nutné uvádět úplné jméno balíku ve volání metod či odkazu na třídu (např. java.util.date) nebo použít klauzuli import (viz následující kapitola). Řetězce (třída String) Pro práci se řetězci (tj. s posloupností znaků jako je v našem příkladě "Muj prvni program") se v jazyce Java používá třída String. Třída String slouží k ukládání konstantních řetězců, jejichž hodnota se během činnosti programu nezmění (jedná se o příklad tzv. read-only třídy) toto však neznamená, že stejný identifikátor nemůže v průběhu programu ukazovat na různé hodnoty (různé instance). Instanci třídy String lze definovat třemi způsoby. explicitně následující definicí: String s = new String("abcd"); implicitně, kdy překladač automaticky doplní potřebný kód pro vytvoření instance typu String: String s = "abcd"; implicitně, kdy se nedefinuje ani identifikátor (odpovídá konstantě primitivních datových typů): "abcd"; Pro práci s řetězci jsou definovány operátory + a += pro spojení dvou řetězců (instancí třídy String) do nové instance třídy String (do nového řetězce) 8. Při použití operátoru += (např. retezec1 += retezec2) se odkaz na novou instanci přiřadí k identifikátoru uvedenému na levé straně výrazu. Různé způsoby deklarace a použití řetězců si ukážeme v následujícím příkladě. public class Retezce { public static void main (String args[ ]) { int cislo = 10; String retezec1 = "Vysledek je"; String retezec2 = new String ("korun"); System.out.println(retezec1 + " " + cislo + " " + retezec2); Příklad vypíše následující řádek: Vysledek je 10 korun Pokud se k řetězci připojuje operátorem + jednoduchá proměnná (int, long,...), překladač automaticky zajistí převod proměnné na typ String (viz předchozí příklad, parametr příkazu println). Pokud se k řetězci připojuje instance objektu, překladač automaticky doplní volání metody tostring(), která převede objekt na řetězec. Stejný způsob vyjádření objektu se používá i v některých metodách, např. v často používaných metodách print a println. Následující řádek: System.out.println (new Date()); který vypíše aktuální datum a čas, překladač interpretuje, jako kdyby vypadal následovně: 17

18 Základy jazyka Date datum = new Date(); System.out.println(datum.toString()); Při práci s řetězci v programu je třeba si uvědomit, že řetězce nejsou jednoduché proměnné, ale instance třídy String. Když potřebujeme porovnat obsah dvou řetězců, nelze použít následující porovnání retezec1 == retezec2 // SPATNE protože tato podmínka porovnává, jestli oba identifikátory odkazují na stejnou instanci (na stejné místo v paměti). Pro porovnání obsahu dvou řetězců musíme použít metodu equals třídy String. Syntaxe porovnání řetězců retezec1 a retezec2 je následující: retezec1.equals(retezec2) // DOBRE a výsledek je typu boolean. Následující příkaz retezec1 = retezec2 nevytvoří kopii řetězce, ale přiřadí identifikátoru retezec2 odkaz na instanci, na kterou odkazuje identifikátor retezec1. Vytvořit kopii (tj. novou instanci se stejným obsahem) lze následujícím příkazem String retezec2 = new String(retezec1) 9 Pro převody primitivních datových typů na řetězce je ve třídě String definována metoda třídy valueof(). Například String retezec1 = String.valueOf(3.7629) uloží do objektu retezec1 hodnotu jako řetězec 10. Stejného výsledku lze dosáhnout i následujícím výrazem String retezec1 = "" kdy se využije vlastnosti automatické konverze proměnných na řetězec. Tato druhá varianta je však náročnější na rychlost zpracování, neboť zde se vedle konverze musí vytvořit objekt typu String s prázdným řetězcem a oba řetězce se musí spojit. Metoda String.valueOf s parametrem typu objekt vrací na výstupu výsledek metody tostring() příslušného objektu. Ke třídě String existuje alternativní třída StringBuffer, která na rozdíl od třídy String není read-only - při změnách nevytváří nové instance, čímž lze dosáhnout větší efektivity programu. Má obdobné metody jako třída String. 8 Jedná se o jediné případy přetížení (overloading) operátorů v Javě. 9 Pro vytváření kopií objektů se doporučuje používat metodu clone(), třída String tuto metodu však nemá implementovánu. 10 Při prohlížení tohoto výrazu mohou u některých čtenářů vzniknout pochybnosti, proč zde není operátor new pro vytvoření nového objektu. Metoda String.valueOf sama uvnitř vytvoří novou instanci třídy String a na výstupu vrací pouze odkaz na tuto instanci, který se přiřadí k příslušnému identifikátoru. 18

19 Základy jazyka Komentáře Pokud tvoříme program, je nezbytné uvádět v něm komentáře pro objasnění činnosti programu. Tyto komentáře poslouží jednak jiným programátorům pro pochopení vašeho programu, jednak i nám samotným, pokud se k programu vrátíme po delší době. Navíc firma Sun kromě překladače poskytuje i nástroj na automatické generování dokumentace z komentářů ve zdrojovém textu programu (javadoc). Krátký komentář je možno uvést přímo za příkaz, který chceme okomentovat. Komentář uvedeme se dvěma lomítky na začátku. Při překladu bude text od tohoto označení do konce řádku ignorován. Komentář delší než řádek začneme takto /* a ukončíme */, text mezi značkami je při překladu ignorován. Pokud chceme, aby byl komentář součástí automaticky generované dokumentace použijeme na začátku značku /** a ukončíme ho */. 19

20 Třídy 3. Třídy Základní pojmy objektového programování Jak už víme, je Java objektovým programovacím jazykem. V úvodu této kapitoly si objasníme základní pojmy objektové teorie. Objekt představuje souhrn dat a činností, které od něj můžeme žádat. Každý objekt má určité rozhraní, prostřednictvím kterého komunikuje s jinými objekty. Pro začátek si můžeme představit, že když tvoříme program pomocí objektů, skládáme ho obdobně jako např. stavbu z Lega. Je pro nás důležité, aby bylo možno je spojit a celek byl funkční, ale jak jednotlivé objekty dojdou uvnitř k výsledkům nás nezajímá. Když vytváříme program v objektovém jazyce, nepopisujeme jednotlivé objekty, ale třídy objektů. Třída (class) je obecný popis vlastností a činností objektů. Například budeme chtít pracovat se studenty, vytvoříme třídu Student, která bude obecně popisovat všechny studenty, jejich vlastnosti (např. jméno, příjmení, datum narození, adresu, absolvované kurzy, známky atd.) a činnosti (vytvoření nového studenta, zapsání předmětu, změna adresy atd.). Pokud potom vytvoříme konkrétního studenta Jana Nováka vytvoříme instanci třídy. Těchto instancí může k jedné třídě existovat libovolné množství. Java nám poskytuje řadu tříd, uložených v standardních knihovnách, které nám ulehčí práci (např. třídy pro práci se soubory, textovými řetězci, třídy poskytující matematické funkce, třídy pro tvorbu grafického rozhraní atd.). Třída popisuje vlastnosti jednotlivých instancí prostřednictvím proměnných (ekvivalentní jsou označení datové členy nebo datové atributy). Naše třída Student bude mít např. proměnnou jméno, tato proměnná bude v každé instanci nabývat různé hodnoty (např. Jan, Pavel, Petra, Tereza, Pavel,...). Při definici proměnné musíme určit její datový typ, tj. jestli v proměnné bude uloženo číslo, řetězec textu, instance jiné třídy atd. Takováto proměnná se označuje jako proměnná instance. Můžeme si také nadefinovat proměnnou počet, která bude součástí třídy Student a bude sloužit pro evidenci počtu studentů. Takováto proměnná není součástí jednotlivých instancí, existuje pouze jednou a je přístupná všem instancím třídy, označujeme ji jako proměnnou třídy. Dále třída obsahuje metody popisující chování (činnosti) jednotlivých instancí (metody instance) nebo společné všem instancím (metody třídy). Zapouzdření je jedna ze základních vlastností objektů. Jde vlastně o skrytí detailů implementace při zachování funkčnosti dostupné jiným objektům. Část objektu, která je dostupná ostatním objektům, se nazývá rozhraní objektu. Dědičnost je dalším ze základních rysů objektového programování. Umožňuje nám lépe využít již vytvořené třídy. Pokud již existuje třída, která částečně splňuje naše požadavky, pouze potřebujeme přidat nějakou vlastnost nebo činnost, využijeme v rámci objektového programování právě dědičnost. Již existující třídy lze rozšiřovat a doplňovat tak, že novou třídu definujeme jako potomka (odvozenou 20

21 Třídy třídu, podtřídu, dceřinou třídu) stávající třídy (nadtřídy, rodičovské třídy, bázové třídy). Potomek zdědí všechny proměnné a metody nadřízené třídy. Např. máme třídu Tvar, která obecně popisuje společné vlastnosti a činnosti všech dvourozměrných tvarů. Můžeme vytvořit několik dalších tříd, které budou tyto vlastnosti přebírat a rozšiřovat např. Kruh, Čtverec a Trojúhelník. Grafické znázornění pomocí zjednodušeného zápisu z UML vidíme na obrázku č. 1. Tvar Kruh Čtverec Trojúhelník obrázek 1 Jednoduché znázornění dědičnosti pomocí UML Do nové třídy můžeme přidat další proměnné a metody. Třída Tvar bude obsahovat činnost nakresli. Všechny třídy, jejichž předkem je třída Tvar, budou tedy obsahovat metodu nakresli. V našem případě se ale obecná metoda nakresli pro jednotlivé podtřídy nehodí, potřebujeme již kreslit konkrétní tvary. Tato situace však neznamená, že dědičnost nelze použít. Využijeme další z objektových vlastností a to je polymorfismus tj. vytvoříme novou metodu stejného názvu ale jiného obsahu a tou původní metodu nakresli překryjeme (v angličtině se používá termín overriding). V jedné třídě může být definováno několik metod stejného jména, které se liší pořadím a počtem parametrů. Tomuto říkáme přetěžování (overloading) metod. Například pro kreslení kruhu můžeme chtít vytvořit metodu, která nakreslí kruh barvou, jaká je právě nastavena v systému, a jindy budeme chtít metodu, která nakreslí kruh námi zadanou barvou. Nemusíme hledat jiný název pro kreslení se zadanou barvou, i tato metoda se může jmenovat nakresli a bude mít navíc parametr pro určení barvy. Obecně lze vytvořit i třídu, která má více přímých předků, tento jev se nazývá vícenásobná dědičnost. Java však umožňuje pouze jednonásobnou dědičnost tj. třída v Javě může mít jen jednoho předka ( to ale neznamená, že tento předek nesmí mít svého předka atd.). V jazyce Java jsou všechny třídy potomkem třídy Object, jedině tato třída nemá v Javě předka. 21

22 Třídy Deklarace třídy v Javě Deklaraci třídy v Javě lze schématicky popsat následovně: [ package JménoBalíku; ] [ import JménoTřídy, ; ] public [final abstract] class jmeno [extends JménoRodičovskéTřídy] [implements JménoRozhraní ] { proměnné třídy; proměnné instancí; vnořené třídy; konstruktory; metody; případné neveřejné třídy; Klauzule package slouží pro zařazení třídy do určitého balíku (package). Pokud se tato klauzule neuvede, bude třída zařazena do tzv. nepojmenovaného balíku. Popis práce s balíky je nad rámec rozsahu těchto skript. Nepovinná klauzule import slouží pouze pro zjednodušení psaní odkazů na jednotlivé třídy. Např. pokud chci ve své třídě vytvořit instanci třídy java.util.random, mám dvě možnosti, jak se na tuto třídu odkázat: použít celé jméno java.util.random (přehlednější, jednoznačné, náročnější na psaní) zadat na začátku klauzuli import java.util.random a poté používat jméno Random V klauzuli import lze zadat více tříd a lze též použít i hvězdičky. Např. zápis import java.util.*; umožňuje zkráceně psát jména všech tříd z balíku java.util. Používání hvězdiček však může vytvářet velmi nepříjemné a těžko odhalitelné chyby v případě, že existují duplicity ve jménech objektů v různých balících. Překladač Javy automaticky při překladu doplní import třídy java.lang, tj. nemusíme pro používání prvků tohoto balíku uvádět příslušný import. Modifikátory tříd Před klíčovým slovem class lze použít klíčová slova public, final a abstract, jejichž význam a způsob použití si nyní vysvětlíme. Je-li třída definována jako public, může se na ni odkazovat jakákoli jiná třída. Pokud klíčové slovo public nepoužijeme, může být třída zpřístupňována pouze ostatními třídami z balíku. V jednom zdrojovém souboru může být nejvýše jedna třída, která je definovaná jako public. 22

23 Třídy Klíčové slovo final označuje třídu, od níž již nelze definovat potomky. Klíčovým slovem abstract označujeme třídu, od které nelze vytvářet žádné instance a která se používá jako předek pro další třídy (lze zde nadefinovat, co vše mají tyto třídy společné). Jedině abstraktní třída může obsahovat abstraktní metody. Je možná pouze kombinace public abstract. Definice a používání abstraktních tříd není součástí těchto skript. Jméno třídy by mělo začínat velkým písmenem. Pokud chceme novou třídu vytvořit jako potomka některé jiné třídy, uvedeme za jménem třídy klíčové slovo extends následované jménem třídy předka (třída musí mít pouze jednoho předka, pokud není uveden, automaticky se doplní jako předek třída Object 11 ). Pokud chceme aby naše třída implementovala rozhraní, použijeme klíčové slovo implements následované jménem jednoho či více rozhraní. Je možno uvést obojí tj. dědění i implementaci rozhraní. V definici třídy není ani jedna část povinná, viz náš úvodní příklad, který obsahoval pouze metodu main. Jestli bude námi vytvářená třída obsahovat proměnné, vnořené třídy nebo konstruktory a kolik v ní bude metod, závisí na logice toho, co tvoříme. Proměnné tříd a instancí Deklarace proměnných Proměnné mohou být buď primitivního typu nebo to jsou instance tříd. Vše co jsme si řekli o deklaraci primitivních typů, které používáme jako pomocné proměnné v metodách, platí i pro proměnné objektů, pouze s tím rozdílem, že před identifikátorem typu mohou být uvedeny některé modifikátory (public, protected, private, static, final). Modifikátory public, protected a private určují rozsah dostupnosti proměnné a může být uveden maximálně jeden z nich. Jestliže označíme proměnnou modifikátorem private, bude přístupná pouze ve třídě obsahující její definici. Proměnná deklarovaná jako private není dostupná ani potomkům této třídy. Proměnná označená jako protected je dostupná pro všechny třídy se stejného balíku a ve všech třídách vytvořených jako potomci této třídy, a to i v případě, že třída potomka je z jiného balíku. Proměnná označená jako public je dostupná z jakékoli třídy. Pokud není žádný z těchto modifikátorů uveden, je u proměnné definován implicitní (přátelský) přístup - proměnná je přístupná v jakékoli třídě, která je součástí stejného balíku a nepřístupná mimo něj. Je tedy rozdíl mezi deklarací s modifikátorem protected a bez modifikátoru. Modifikátor static určuje, že se jedná o proměnnou třídy. To znamená, že v dané třídě existuje právě jeden výskyt této proměnné a všechny instance této třídy jej sdílejí. Změna hodnoty této proměnné tedy znamená změnu pro všechny instance. Pokud tento modifikátor není uveden, jedná se o proměnnou instance. Každá vytvořená instance této třídy má svou kopii proměnné instance a její změna v jedné instanci se nedotkne ostatních instancí. 23

24 Třídy Modifikátor final označuje konstantu. Takto označené proměnné může být přiřazena hodnota pouze jednou. Jakékoli další přiřazení nové hodnoty je překladačem označeno jako chyba. Příklady: protected int pocet = 10; private float objem; public static final int MAXIMALNI_POCET = 100; protected String jmeno; Práce s proměnnými Pokud potřebujeme s proměnnou pracovat v rámci metod třídy ve které byla definována, odkazujeme se na ni pouze jejím jménem. Jestliže potřebujeme s proměnnou pracovat v jiné třídě, odkazujeme se na ni v závislosti na typu proměnné. Když je to proměnná třídy, tak jménem třídy, tečkou a jménem proměnné. Když je to proměnná instance, tak jménem instance, tečkou a jménem proměnné. Je však třeba si uvědomit, že pokud byla proměnná definována jako private, není přímý přístup k této proměnné mimo třídu vůbec možný. Metody Další část deklarace třídy je tvořena deklaracemi metod. Konstruktor je speciální metoda, o které si povíme později. Metoda je část spustitelného kódu. Metodě mohou být při volání předány parametry a metoda může vrátit hodnotu. Deklarace metody vypadá následovně: [ modifikátory ] typ_návratové_hodnoty jméno_metody ( [parametry] ) [ throws jméno_třídy ] Klauzule throws bude vysvětlena později v kapitole o výjimkách. Modifikátory metod Mohou být tyto: public, protected, private, static, abstract, final, native, synchronized. Modifikátory public, protected a private mají stejný význam jako u proměnných a také přístupnost metody bez uvedení jednoho z těchto modifikátorů je stejná jako u proměnných. Modifikátor static určuje, že metoda je metodou třídy tj. voláme ji jménem třídy a před jejím volání nemusí být vytvořena žádná instance této třídy. Pokud tento modifikátor není uveden, je metoda metodou instance. Metodu označenou jako static nelze u potomka třídy předefinovat. Metoda, která je definována s modifikátorem final, je metoda, kterou již nelze předefinovat. To tedy znamená, že žádný z potomků této třídy nesmí obsahovat metodu stejného jména se stejným počtem a pořadím parametrů. Modifikátor final však neznamená, že metoda nemůže být přetížena. Abstraktní metoda (s modifikátorem abstract) musí za deklarací končit středníkem, nesmí tudíž obsahovat žádnou implementaci, pouze deklaraci návratového typu a případně parametrů. Abstraktní 11 Úplné jméno je java.lang.object 24

25 Třídy metody mohou být deklarovány pouze v abstraktních třídách. Implementace této metody musí být uvedena u potomka abstraktní třídy, ve které je metoda uvedena. Není přípustná kombinace modifikátoru abstract s modifikátorem private ani static. Modifikátor native označuje metodu zapsanou v jiném programovacím jazyce. Modifikátor synchronized se používá k synchronizaci metod v rámci více vláken jednoho procesu. Typ návratové hodnoty V deklaraci metody musí být vždy uveden typ návratové hodnoty. Pokud metoda nevrací hodnotu, je typ označen jako void. Metoda, která má definován jiný typ návratové hodnoty než void, musí být ukončena příkazem return vracejícím hodnotu odpovídajícího typu. Vstupní parametry metody Za jménem metody uvádíme v kulatých závorkách seznam formálních parametrů. Počet parametrů není omezen, ale budete-li někdy psát metodu s více než pěti parametry, zamyslete se jestli do ní nesdružujete zbytečně mnoho činností. Při definování parametrů uvádíme jejich typ a uvnitř metody s nimi pracujeme jako s proměnnými. Jako oddělovač jednotlivých parametrů používáme čárku. U každého parametru musí být jeho typ uveden samostatně, zápis static int max (int a, b) není možný, je třeba uvést static int max (int a, int b). Skutečné hodnoty parametrů dosadíme při volání metody. Pokud metoda nemá žádné vstupní parametry, je třeba při deklaraci i při volání takovéto metody uvést za jejím jménem prázdné závorky. Příklad 1: metoda, která vrací hodnotu většího ze vstupních parametrů: static int max (int a, int b) { if (a > b) return a else return (b); System.out.println.( Konec metody ); //toto se neprovede V tomto příkladě jsme deklarovali metodu max (jméno metody by mělo začínat malým písmenem), která je metodou třídy, vrací hodnotu typu int a má dva parametry typu int. Vrácení většího z čísel je realizováno pomocí příkazu return. Příkazem return provádění metody končí. Nemá tedy smysl uvádět poslední řádek v našem příkladě. Také si všimněte, že hodnota výstupu z metody u příkazu return byla přiřazena pokaždé jinak, obě varianty (se závorkami i bez) jsou správné. Pokud je metoda max deklarována ve třídě Pokus a spouštíme ji v rámci jiné metody stejné třídy, může vypadat její volání následovně: System.out.println("Vetsi je :"+max(cislo1,cislo2)); nebo int vetsi = max(cislo1,cislo2); 25

26 Třídy Pokud je tato metoda volána z jiné třídy, vypadá její volání takto: System.out.println("Vetsi je :"+Pokus.max(cislo1,cislo2)); nebo int vetsi = Pokus.max(cislo1,cislo2); Metoda max je metodou třídy (modifikátor static), proto ji lze volat buď jen jménem nebo jménem třídy a jménem metody bez nutnosti vytvoření instance. Příklad 2: metoda pro jednoduchý tisk. static void tisk(string s){ System.out.println(s); Zde jsme definovali metodu tisk, jako metodu s návratovým typem void a jedním parametrem typu String. V této metodě nemusí být uveden příkaz return a metoda končí provedením všech příkazů v ní uvedených. Pokud uvedeme v takovéto metodě příkaz return, musí být prázdný tj. nesmí za ním být uveden žádný výraz. Volání této metody je v podstatě stejné jako volání v minulém příkladě, pouze s tím rozdílem, že se uvádí jako samostatný příkaz. Např.: tisk("ahoj"); Pokus.tisk ("Nejaky text"); Předávání hodnot parametrů Při předávání parametrů metodě je třeba si uvědomit, že primitivní typy jsou předávány jinak než referenční. Primitivní typy jsou předávány hodnotou, tj. po dobu činnosti procedury se vytvoří kopie původní hodnoty a s tou metoda pracuje. Po skončení činnosti metody je tato kopie zrušena, ale její hodnota není převedena do původní proměnné. Důsledky si ukážeme na následujícím příkladě. static int zvetsenioctyri (int i){ i += 4; return i; část metody main: int a, b =1; b = zvetsenioctyri(a); System.out.println("a = "+ a+" b = "+b); Výpis bude vypadat takto: a = 1 b = 5 Hodnota proměnné a je použita jako vstupní hodnota pro spuštění metody zvetsenioctyri, ale dál už se s ní nepracuje. Při spuštění metody se vytvoří lokální proměnná (zde pojmenovaná písmenem i) a její změna se do proměnné a nepromítne. Parametry referenčních typů jsou předávány odkazem, tzn. že se pracuje i v metodě se stejnými daty. Důsledek si nejlépe uvědomíme na příkladě: 26