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
4
Znak $ není vhodné používat, neboť ho překladač používá při vytváření interních proměnných.
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 long
Velikost (v bytech) 8
int
4
short byte double
2 1 8
float char boolean
4 2 1 bit
Rozsah -9 223 372 036 854 775 808 až +9 223 372 036 854 775 807 -2 147 483 648 až +2 147 483 647 -32 768 až +32 767 -128 až +127 ±1.797 693 134 862 315 70 E+308 ±3.402 823 47 E+38 65 536 různých znaků true nebo false
Implicitní hodnota2 0 0 0 0 0.0 0.0 \u0000 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. Součástí deklarace proměnných mohou být modifikátory (public, static, final atd.) jejichž význam bude popsán později. 3
5
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, 0.00002) nebo se používá tzv. semilogaritmický zápis, kdy číslo 1.54 * 106 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
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 100000L4 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 = 0.123456789; 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 100000 * 100000 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
Základy jazyka 1 410 065 408 typu int místo správného 10 000 000 000, 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ě: 100000L * 100000. 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
+= -= /= *= %= ++
x += y x -= y x /= y x *= y x %= y x++ ++x x---x
--
Význam operátoru x=x+y x=x-y x=x/y x=x*y x=x%y x=x+1 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žel6) 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
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ínky7. Přehled relačních operátorů je v následující tabulce (pozor, nelze zaměnit pořadí znaků v operátorech):
relační operátor == != < > <= >=
význam rovná se nerovná se menší než větší než menší nebo rovno větší nebo rovno
tabulka 3 Relační operátory
Logické operátory 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
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
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() * 10 + 1); System.out.println ("Cislo1=" + cislo1); int cislo2 = (int) (Math.random() * 10 + 1); 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
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 :
Příklad2 switch ( i ) { case 1 : prikaz1; break;
prikaz1; case 2 :
case 2 :
prikaz2; default : prikaz3;
prikaz2; break; default : prikaz3;
}
} tabulka 4 Porovnání příkazu switch s break a bez něj
Hodnota proměnné i
Provedené příkazy příklad1
Provedené příkazy příklad2
1
prikaz1
2
prikaz2
jiná hodnota
prikaz3
prikaz1 prikaz2 prikaz3 prikaz2 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
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
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: 0 1 2 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: 0 1 2 4 5 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
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
Základy jazyka Metoda static int abs (int a); static long abs (long a); static float abs (float a); static double abs (double a); static long round (double a); static int round (float a); static double sqrt (double a); 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);
Popis vrátí absolutní hodnotu parametru
Přiklad cislo2 = Math.abs(cislo1)
vrací nejbližší celé číslo výpočet druhé odmocniny trigonometrické funkce
cislo2 = Math.sqrt(cislo1)
umocňování, ab vrací menší z obou hodnot vrací větší z obou hodnot
tabulka 6 Metody třídy Math
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
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
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 3.7629 jako řetězec10. Stejného výsledku lze dosáhnout i následujícím výrazem String retezec1 = "" + 3.7629 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ě. 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. 9
18
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
