java cupic

Programiranje u JaviMarko upi

Programiranje u JaviMarko upiOvo je verzija 0.3.4 knjige o programiranju u programskom jeziku Java. Napisani tekst odnosi se naverziju 7 programskog jezika Java.Autorska prava 2012. - 2013. Marko upi

NapomeneUporaba ove knjige dozvoljava se studentima FER-a koji je ele koristiti u svrhu uenja programskog jezika Java. Za bilo kojidrugi sluaj molim javite se elektronikom potom na adresu autora ([email protected]).

iPosvetaPosveeno svima koji ele nauiti programirati, a potom i programirati u Javi.

iii

SadrajPredgovor ................................................................................................................. xi1. Java jezik, platforma, ekosustav ........................................................................... 1

Postupak prevoenja i izvoenja Java programa .................................................. 3Javin virtualni stroj ............................................................................................. 5

Jezici podrani od JVM-a ........................................................................... 6Podrani tipovi podataka .................................................................................... 7

Primjeri literala ........................................................................................... 9Inicijalizacija vrijednosti ............................................................................. 11Pretvorbe primitivnih tipova u string ........................................................... 11Omotai primitivnih tipova ......................................................................... 12

Uvjetno izvoenje, petlje i decimalni brojevi ....................................................... 132. Prvi Java program ................................................................................................ 21

Prevoenje programa ....................................................................................... 23Pokretanje izvrnog programa ........................................................................... 24Sloeniji primjer ................................................................................................ 25Pakiranje izvrnog programa u arhivu ................................................................ 27Generiranje dokumentacije ................................................................................ 29Pisanje dokumentacije projekta ......................................................................... 30

Dokumentiranje paketa ............................................................................. 30Dokumentiranje razreda ............................................................................ 30Dokumentiranje metoda ............................................................................ 31

Automatizacija razvojnog ciklusa ....................................................................... 32Uporaba alata ant .................................................................................... 33Uporaba alata maven ............................................................................... 38Uporaba alata gradle ............................................................................... 40

3. Osiguravanje kvalitete i ispravnosti koda ................................................................ 43Alat CheckStyle ................................................................................................ 48Alat PMD ......................................................................................................... 50Alat FindBugs .................................................................................................. 53Alat JUnit ......................................................................................................... 55Alat JaCoCo .................................................................................................... 61

4. Jednostavniji primjeri ............................................................................................ 695. Razredi ................................................................................................................ 716. Upravljanje pogrekama. Iznimke. ......................................................................... 737. Apstraktni razredi. Suelja. .................................................................................... 75

Programiranje prema sueljima ......................................................................... 75Motivacijski primjer ................................................................................... 77Oblikovni obrazac Iterator ......................................................................... 80

8. Naela objektno-orijentiranog oblikovanja ............................................................... 83Na vrstim temeljima ........................................................................................ 85

Naelo jedinstvene odgovornosti ............................................................... 87Naelo otvorenosti za nadogradnju a zatvorenosti za promjene ................... 92Liskovino naelo supstitucije ..................................................................... 98Naelo izdvanja suelja .......................................................................... 109Naelo inverzije ovisnosti ........................................................................ 114

A. Instalacija JDK ................................................................................................... 115Operacijski sustav Windows ............................................................................ 115Operacijski sustav Linux ................................................................................. 116

B. Instalacija alata ant, maven i gradle ................................................................... 117Alat Apache Ant ............................................................................................. 117Alat Apache Maven ........................................................................................ 117Alat Gradle ..................................................................................................... 118

C. Instalacija alata za kontrolu kvalitete i ispravnosti koda ......................................... 119Alat CheckStyle .............................................................................................. 119Alat PMD ....................................................................................................... 120

Java

iv

Alat FindBugs ................................................................................................. 120Alat JUnit ....................................................................................................... 120Alat JaCoCo ................................................................................................... 121Biblioteka Mockito ........................................................................................... 121

Bibliography ........................................................................................................... 123

vPopis slika1.1. Od izvornog koda do programa u izvoenju .......................................................... 32.1. Pojednostavljen popis zadataka u razvojnom procesu .......................................... 343.1. Saetak izvjetaja o kontroli stila pisanja koda ..................................................... 503.2. Izvjetaja o kontroli stila pisanja koda datoteke Formule.java ........................... 503.3. Saetak izvjetaja o kontroli stila pisanja koda ..................................................... 533.4. Saetak izvjetaja o dupliciranju koda ................................................................. 533.5. Saetak izvjetaja o kontroli kvalitete koda .......................................................... 553.6. Izvjetaj o pokrenutim testovima ......................................................................... 603.7. Detaljni pregled jednog izvjetaja o pokrenutim testovima ..................................... 613.8. Izvjetaj o pokrivenosti koda .............................................................................. 663.9. Detaljniji izvjetaj o pokrivenosti koda ................................................................. 663.10. Izvjetaj o pokrivenosti koda u razredi PrirodniTest ...................................... 663.11. Izvjetaj o pokrivenosti koda u razredi Prirodni .............................................. 663.12. Detaljni grafiki prikaz o pokrivenosti koda u razredu Prirodni ......................... 677.1. Razredi i suelja motivacijskog primjera .............................................................. 807.2. Dijagram razreda za oblikovni obrazac Iterator .................................................... 818.1. Organizacija dnevnikog podsustava .................................................................. 978.2. Organizacija loeg rjeenja ............................................................................... 1118.3. Organizacija boljeg rjeenja .............................................................................. 114

vii

Popis tablica1.1. Primitivni tipovi u programskom jeziku Java .......................................................... 7

ix

Popis primjera1.1. Ilustracija raunanja s ogranienom preciznou te usporedba rezultata ................ 181.2. Usporedba jednakosti decimalnih brojeva ............................................................ 192.1. Primjer programa napisanog u programskom jeziku Java ..................................... 222.2. Sloeniji primjer -- ispis sluajno odabrane formule .............................................. 262.3. Primjer dokumentacije paketa ............................................................................. 302.4. Primjer dokumentacije razreda ........................................................................... 312.5. Primjer dokumentacije metode ............................................................................ 322.6. Primjer konfiguracije za alat ant ......................................................................... 342.7. Definicija cilja runjar za alat ant ......................................................................... 372.8. Pregledna stranica za dokumentaciju programa ................................................... 382.9. Definicija cilja javadoc za alat ant ....................................................................... 382.10. Primjer osnovne verzije datoteke pom.xml ....................................................... 392.11. Zadavanje verzije prevodioca koji je potrebno koristiti u datoteci pom.xml ........... 402.12. Konfiguracijska datoteka build.gradle za alat gradle .................................... 413.1. Implementacija biblioteke za rad s prirodnim brojevima ........................................ 553.2. Testovi za razred Prirodni. ............................................................................. 563.3. Datoteka build.xml za pokretanje testova. ....................................................... 573.4. Cjelokupna datoteka build.xml koja koristi alat JaCoCo .................................... 637.1. Suelje java.util.Iterator ................................................................... 757.2. Suelje java.lang.Iterable ................................................................... 767.3. Obilazak skupnog objekta koji implementira suelje java.lang.Iterable................................................................................................................................. 767.4. Implementacija skupnog objekta koji predstavlja zadani podniz parnih brojeva ........ 777.5. Implementacija klijenta za skupni objekt .............................................................. 798.1. Generiranje izvjetaja, prvi pokuaj ..................................................................... 878.2. Generiranje izvjetaja, drugi pokuaj ................................................................... 888.3. Generiranje izvjetaja, trei pokuaj .................................................................... 898.4. Razred Student ............................................................................................... 908.5. Razred Student i primjena naela jedinstvene odgovornosti ............................... 918.6. Primjer problematine metode racunajPovrsinu .............................................. 928.7. Bolji primjer metode racunajPovrsinu ............................................................ 948.8. Primjer izrade dnevnikog podsustava ................................................................ 958.9. Bolji primjer izrade dnevnikog podsustava ......................................................... 968.10. Viestruko zapisivanje dnevnikih poruka .......................................................... 988.11. Geometrijski podsustav .................................................................................... 998.12. Primjer uporabe ............................................................................................. 1008.13. Implementacija kvadrata ................................................................................. 1018.14. Popravljena implementacija kvadrata ............................................................... 1018.15. Nadogradnja glavnog programa ...................................................................... 1028.16. Mogue rjeenje ............................................................................................ 1038.17. Lokalizirane poruke ........................................................................................ 1058.18. Poruke bez mogunosti auriranja .................................................................. 1068.19. Poruke bez mogunosti auriranja .................................................................. 1068.20. Problematina organizacija koda ..................................................................... 1098.21. Bolja organizacija koda .................................................................................. 112

xi

PredgovorBit e jednom napisan.

1Poglavlje1.Java jezik, platforma,ekosustav

Programski jezik Java nastao je iz programskog jezika Oak. Poev od 1995. godine kadaje u u internet preglednik Netscape Navigator ugraena podrka za Javu pa sve do danas,jezik se razvija i iri te je danas praktiki sveprisutan.

Jedna od temeljnih vodilja u razvoju ovog jezika, koja je dovela do ovakve ope prihvae-nosti, jest ideja napii-jednom-pokreni-bilo-gdje. Centralna tema u razvoju Jave je potporaza vieplatformnost, odnosno ideja da se programeru ponudi apstraktni pogled na raunalo-- pogled koji ne ukljuuje platformski specifine detalje poput irine podatkovne rijei cen-tralnog procesora, direktan pristup upravljakim programima operacijskog sustava ili podr-anom sklopovlju. Umjesto toga, Java definira apstraktni raunski stroj kod kojeg je sve pro-pisano i opisano specifikacijom. Za programera je u konanici skroz nebitno hoe li se njegovprogram izvoditi na 16-bitnom, 32-bitnom ili 64-bitnom procesoru.

Da bi to bilo mogue, prilikom programiranja u Javi programi se piu za Javin virtualni stroj.To je stroj koji je definiran specifikacijom [7] i na kojem se izvode svi programi pisani u Javi.Zahvaljujui ovakvoj virtualizaciji, programer doista ne treba (i ne moe) razmiljati o speci-finostima platforme na kojoj e se izvoditi program koji je napisao, a to upravo i jest idejaizrade aplikacija za vie platformi odjednom. Dakako, na svakoj konkretnoj platformi morate postojati implementacija Javinog virtualnog stroja koja e u konanici biti svjesna na kojojse platformi izvodi te kako se na toj platformi obavljaju pojedini zadatci (poput pristupa dato-tenom sustavu, mrenim resursima, viedretvenosti i slino).

Pa to je sve danas Java? Termin Java danas se koristi u nekoliko razliitih znaenja.

Java kao programski jezik

Java kao platforma

Javin virtualni stroj (JVM, engl. Java virtual machine)

JRE, JDK (SDK)

Java ekosustav

U najuem znaenju, pojam Java odnosi se na programski jezik. Najnovija verzija program-skog jezika Java definirana je specifikacijom [6]. U okviru te specifikacije definira se nainpisanja literala, kljune rije jezika, njihova semantika te nain pisanja valjanog koda. Podpojmom "valjanog" ovdje podrazumjevamo sintaksno i semantiki ispravnog koda sa staja-lita jezinog prevodioca koji izvorni Java kod treba obraditi i stvoriti izvrni kod za Javinvirtualni stroj.

Nauiti programski jezik Javu (u najuem moguem smislu rijei) moe se vrlo brzo: pravilapisanja koda su vrlo jednostavna, kljunih rijei nema puno (par desetaka) i to se sve moenauiti ekspresno. Meutim, jezik sam po sebi je zapravo poprilino beskoristan. Da bismomogli djelotvorno pisati programe, potreban nam je skup biblioteka ijom emo uporabommoi obavljati eljene funkcije (pristupiti datoteci, stvoriti prozor u grafikom korisnikom su-elju, raditi s razliitim vrstama podatkovnih kolekcija i slino). Osnovni skup biblioteka kojeprogrameru stoje na raspolaganju dio su Java platforme i opisane su u okviru dokumentaJava API [2]. Neovisno o platformi na kojoj se Java program izvodi, programeru se garantirada e mu na raspolaganju biti sve bibloteke koje su opisane u okviru tog dokumenta.

Javin virtualni stroj jo je jedan od naina na koji se moe interpretirati pojam Java. To jevirtualni stroj definiran specifikacijom [7] koji stoga ima definiran skup podranih instrukcija(takozvani bajtkod, engl. bytecode), nain dobivanja programa te nain na koji se kod izvo-di. Umjesto kroz programski jezik Java, programeri programe mogu pisati koristei direktno

2bajtkod koji je namijenjen upravo Javinom virtualnom stroju, pri emu se i dalje zadravaportabilnost tako napisanih programa. To je, u odreenom smislu, jednako kao da piemoprogram za neki "virtualni procesor". U okviru ove knjige neemo se baviti time.

Programere koji se po prvi puta susreu s programskim jezikom Java esto znaju zbunitidva pojma: JRE te JDK (ili u ranijim verzijama SDK). Evo o emu se radi. Programeri pro-grame piu zadavanjem izvornog koda u programskom jeziku Java (tekstovne datoteke sekstenzijom .java. Izvorni se kod potom prevodi u izvrni kod odnosno bajtkod (datoteke sekstenzijom .class). Da bi se izvrni program mogao pokrenuti, potreban je Javin virtualnistroj te skup biblioteka ije se postojanje garantira svim Java programima. Ovaj postupakprikazan je na slici 1.1. S obzirom na opisani proces, sada je jasna podjela platforme nadvije komponente. JRE predstavlja osnovni podskup Java platforme koji korisnicima nudimogunost pokretanja prevedenih programa. JRE se sastoji od implementacije Javinog vir-tualnog stroja te obaveznih biblioteka ije se postojanje garantira programima. Ovo je mini-mum koji e svima omoguiti da pokreu izvrne Java programe. Uz navedeno, JRE sadri iimplementaciju dodatka za web-preglednike koji i njima omoguava izvoenje Java progra-ma koje korisnici preuzimaju direktno s Interneta. Pojam JDK predstavlja nadskup opisaneplatforme. JDK sadri sve to je potrebno kako bi programer mogao prevoditi izvorni kodJava programa u bajtkod te kako bi mogao izvoditi Java programe. To znai da JDK u sebiukljuuje JRE te donosi jo i implementaciju prevodioca i drugih pomonih alata. JDK pritome ne sadri okolinu za razvoj Java programa -- pretpostavka je da programeru treba po-nuditi samo jo mogunost prevoenja koda. Na stranicama proizvoaa Jave (od nedavno,to je tvrtka Oracle) mogue je pronai i paket koji sadri okolinu za razvoj programa podnazivom NetBeans. Osim navedene, danas je dostupan jo niz drugih okolina, to besplatniha to komercijalnih, od ega emo svakako preporuiti okolinu otvorenog koda pod nazivomEclipse (http://www.eclipse.org/).

Konano, ovaj pregled ne bi bio potpun kada ne bismo spomenuli da sve do sada opisanopredstavlja samo jedan mali podskup Java platforme koji je poznat pod nazivom Java stan-dard edition, odnosno Java SE. Puno ira specifikacija poznata pod nazivom Java EnterpriseEdition [3] i donosi niz tehnologija koje pokrivaju izradu web aplikacija, rad s bazama poda-taka i raspodijeljeno transakcijsko poslovanje, komuniciranje porukama i jo niz drugih pri-mjena. Postoji i specifikacija koja pokriva izradu Java aplikacija za mobilne ureaje [4] kojameutim iz razliitih razloga u ovom trenutku nije ba najbolje prihvaena, to je pak dovelodo razvoja Googleove platforme Android [5] koja je postala daleko rairenija (za tu platformuprogrami se takoer piu u programskom jeziku Javi; razlika je u skupu podranih bibliotekakoje je u ovom sluaju definirao i odrava Google).

Vana mrena mjestaMreno mjesto s kojega je mogue dohvatiti JRE odnosno JDK dos-tupno je na adresi http://www.oracle.com/technetwork/java/javase/downlo-ads/index.html. Kako biste na raunalo dodali mogunost izvoenja gotovih Ja-va programa potrebno je skinuti i instalirati samo JRE. Ako elite razvijati Javaprograme, tada je potrebno skinuti i instalirati JDK; u tom sluaju nije potrebnoposebno skidati jo i JRE jer je on ukljuen. U trenutku pisanja ovog teksta po-sljednja verzija JDK-a je bila Java SE 7u15.

Spomenimo na kraju pregleda jo i Javin ekosustav. Osim standardnih biblioteka koje sudostupne u okviru Java platforme, oko Java platforme stvoren je bogat i iv ekosustav kojije iznjedrio itav niz drugih biblioteka, razvojnih okvira pa ak i novih programskih jezika kojisu danas u uporabi. Primjerice, ako pogledamo izradu aplikacija za web -- uz standardnetehnologije danas na raspolaganju imamo i niz razvojnih okvira poput Apache Struts, ApacheTapestry, Grails, Google Web Toolkit (GWT), Spring i druge. Imamo na raspolaganju i praverelacijske baze podataka koje su u potpunosti pisane u Javi i koje se mogu koristiti ak i kaokomponente lokalnu unutar vlastitih programa bez eksplicitne instalacije baze podataka --primjeri su baza Apache Derby koja je u posljednjim verzijama Jave ukljuena ak i u SDK(pod nazivom JavaDB), baza H2 te druge. A s obzirom da je Javin virtualni stroj posebnidio Javine platforme, ak i za njega postoji razvijen niz implementacija drugih programskih

Postupak prevoenja i iz-voenja Java programa

3

jezika koje programerima omoguavaju da piu kod u jezicima poput Pythona, Haskella,JavaScripta i slinima te da te programe izvode na Javinom virtualnom stroju ime se i timjezicima nudi portabilnost u punom smislu te rijei.

Postupak prevoenja i izvoenja Java pro-grama

Pogledajmo sada to se sve dogaa od izvornog koda pa do Java programa u izvoenju.Slika 1.1 prikazuje najvanije korake.

Slika1.1.Od izvornog koda do programa u izvoenju

Java izvorni kod(.java)

class Foo { /* ... * /}

Java bytecode datoteke(.class/.jar)

...

iconst_0ialoadistore_1jsr 19iload_1...

javac

Python izvorni kod(.py)

def f(x): print x...

Java bytecode datoteke(.class/.jar)

...

istore_1iload_1jsr 19iconst_0iaload...

jython

CrackBerry

Q W E R T Y U I OP

LJHGFDSA

Z X C V B N M|

SYM0aA space

K

$

aA

7 8 9

654

1 2 3

alt

Mobilni operacijski sustav

ARM JVMProvjerabajtkoda

Upravljanjememorijom(prikupljanje

smea)Interpreter /

JIT prevodioc

Java API

JRE

PC operacijski sustav

Intel x86 JVMProvjerabajtkoda

Upravljanjememorijom(prikupljanje

smea)Interpreter /

JIT prevodioc

Java API

JRE

Postupak prevoenja i iz-voenja Java programa

4

Prvi korak ovog postupka je pisanje izvornog koda u programskom jeziku Java. Dva su nainakako moe nastati izvorni kod: moe ga napisati programer ili izvorni kod moe biti strojnogeneriran.

Sluaj u kojem programer pie izvorni kod najei je oblik nastanka izvornog koda. Izvornikod programa moe se pisati u jednostavnim ureivaima teksta (primjerice, koristei pro-grame Notepad, Notepad++, UltraEdit i sline na Windowsima, pico, joe, vim, emacsna Linuxu, vieplatformne ureivae teksta poput alata jEdit (koji je i sam pisan u Javi)te slinim alatima na drugim operacijskim sustavima. U sluaju izrade iole komplicirani-jih programskih rjeenjapreporuljivo je koristiti okruenja za razvoj programa (engl. IDE- Integrated Development Environment) koja e uz omoguavanje pisanja jedne ili viedatoteka s izvornim kodom automatski ponuditi i mogunost upravljanja projektima, auto-matsko pokretanje postupka prevoenja, automatsku nadopunu prilikom pisanja izvornogkoda te pokretanje i testiranje napisanog programa. Popis ovakvih alata je relativno velik,a najpoznatija su okruenja Eclipse te NetNeans.

Sluaj u kojem se izvorni kod generira automatski rjee se susree prilikom izrade jednos-tavnih programa; meutim, prisutan je u situacijama u kojima se za razvoj sloenih aplika-cija koriste gotovi razvojni okviri. Takvi razvoji okviri specijalizirani su za razvoj odreenihvrsta aplikacija pa omoguavaju programeru da definira i podesi grube obrise aplikacije,na temelju ega razvojni okvir automatski generira potreban izvorni kod koji je naknadnomogue po potrebi jo i korigirati.

Jednom kada raspolaemo izvornim kodovima Java programa (namjerno koristimo mnoinu-- vidjet emo kasnije da je loa praksa pisati ogromne monolitne datoteke i da emo teitimodularnim rjeenjima), sljedei korak predstavlja prevoenje izvornog Java koda u bajtkod.U tu svrhu u okviru instalacije JDK na raspolaganju nam stoji program javac, ije je ime kon-katenacija rijei java te prvog slova engleskog izvornika za jezini procesor: compiler. Pro-gram javac kao ulaz uzima izvorne kodove (te vanjske biblioteke ako ih izvorni kod koristi).Datoteke s izvornim kodovima programskog jezika Java moraju imati ekstenziju .java. Pro-gram potom generira datoteke s izvrnim kodom za Javin virtualni stroj, odnosno datotekekoje sadre bajtkod. Datoteke koje sadre bajtkod imat e ekstenziju .class.

Uoimo odmah da izvorni kod ne treba nuno biti pisan jezikom Java, kao to prethodna sli-ka i pokazuje. Primjerice, ako smo program pisali koristei programski jezik Python, izvornedatoteke imat e ekstenziju .py. U tom sluaju na raunalu bismo morali imati instaliran Jyt-hon: prevodioc koji izvorni kod pisan u jeziku Python prevodi u Javin bajtkod te opet generiradatoteke s ekstenzijom .class. Kako danas za Javin virtualni stroj postoji niz prevodioca,izbor jezika u kojima moemo pisati relativno je velik.

Jednom kada smo generirali bajtkod, postupak prevoenja (barem to se tie nas kao pro-gramera) time zavrava. Bajtkod je izvrni kod za Javin virtualni stroj. Bajtkod je upravo onoto ini nau aplikaciju i bajtkod se predaje drugim korisnicima i instalira na druga raunala(kada korisnici instaliraju na program).

Pokretanja Java programa obavlja se uporabom programa java. Taj program zapravo pred-stavlja implementaciju virtualnog stroja i sastavni je dio svakog JRE-a. Program java kaoulaz uzima upravo bajtkod i potom ga izvodi. Ovom programu pri tome nije vano kako je tajbajtkod nastao -- je li nastao iz Java izvornog koda, iz Python izvornog koda ili nekog treegprogramskog jezika. Jednom kada imamo generirani bajtkod, imamo sve to je potrebno dabismo program pokrenuli. Problem razliitih platforma pri tome nas kao programere vie nezanima -- specifinosti ostvarivanja svih usluga koje Javin virtualni stroj nudi programimaproblem su samog virtualnog stroja i rijeene su na toj razini. To je upravo i razlog zbogkojeg, da bismo dobili mogunost pokretanja Java aplikacija, moramo otii na web-stranicuproizvoaa JRE-a te skinuti i instalirati Javin virtualni stroj za operacijski sustav koji koris-timo. Meutim, kako je kompletna Java platforma definirana kroz niz specifikacija, danasimamo mogunost izbora proizvoaa Javinog virtualnog stroja -- to moe biti Oracle koji jekupio tvrtku Sun koja je idejni tvorac Jave ali i ne mora biti -- danas postoje i druge imple-mentacija Javinih virtualnih strojeva (primjerice, od tvrtke IBM ili od organizacije Apache) kaoi alternativne izvedbe prevodioca za izvorne kodove programa.

Javin virtualni stroj

5

Javin virtualni strojIz dosadanje prie sada ve moemo naslutiti koja je uloga Javinog virtualnog stroja: to jeapstraktni stogovni stroj ija je namjena izvoenja programa pisanih u bajtkodu. Fundamen-talni razlog razvoja Javinog virtualnog stroja je osiguravanje platformske neovisnosti progra-ma koji su pisani u bajtkodu. Da bismo takav program mogli pokrenuti na bilo kojoj platformi,nuno je i dovoljno raspolagati implementacijom Javinog virtualnog stroja za tu platformu. Udananje doba, ove implementacije postoje za sve moderne platforme; poev od klasinihplatformi (Intelovi procesori, AMD-ovi procesori; operacijski sustavi Windows, Linux, OS X)pa do mobilnih platformi.

Sam virtualni stroj aplikacijama nudi apstrakciju dretvi i potporu za njihovo izvoenje (toukljuuje Java stogove) odnosno potporu za pozivanje nativnih biblioteka (to ukljuuje na-tivne stogove i tehnologiju JNI). Virtualni stroj takoer raspolae mehanizmom za dohvat baj-tkoda koji treba izvoditi te apstrakcijom izvrnih jedinica (virtualnih procesora odnosno Javadretvi). Nain na koji e se izvrne jedinice implementirati nije propisan nikakvom specifika-cijom -- tvorci Javinih virtualnih strojeva ovdje imaju potpunu slobodu. Ono to specifikacijepropisuju jest format datoteke .class te popis i semantiku podranih instrukcija. Stoga suprve i najjednostavnije izvedbe Javinih virtualnih strojeva bili upravo interpreterski strojevi:programski sustavi koji su itali instrukciju po instrukciju bajtkoda te interpretirali to ta ins-trukcija treba napraviti i potom to napravili. Ovakve implementacije Javinih virtualnih stroje-va itavu su platformu dovele na lo glas -- Java je bila spora. Danas kada je tehnologijaizrade Java virtualnih strojeva znaajno napredovala, virutalni strojevi i sami se ponaajukao jezini procesori: jezini procesori koji bajtkod tumae kao izvorni kod i potom provodepostupak generiranja strojnog koda za procesor na kojem se izvodi i sam virtualni stroj i pritome provode jo i dodatne optimizacije. Vrhunac ove tehnologije danas predstavljaju jeziniprocesori koji u letu prevode bajtkod u strojni kod uporabom JIT prevodioca (engl. Just-In-Time Compilers). Ideja je pri tome izuzetno jednostavna: prevoenje bajtkoda u strojni kodje vremenski skupa operacija; stoga Javin virtualni stroj dijelove koda koji se rijetko izvodeinterpretira, to uzevi u obzir injenicu da se ti dijelovi rijetko izvode ne povlai velike vre-menske penale a dijelove koda za koje se utvrdi da se esto izvode u letu prevodi u strojnikod. Pri tome se ak i sam postupak prevoenja u strojni kod radi u vie koraka i s razlii-tim razinama optimizacije; naime, to se ukljui vie optimizacija, to je postupak generiranjakonanog strojnog koda sporiji. Stoga virtualni strojevi neprestano prate intenzitet izvoenjapojedinih dijelova programa i potom adaptivno najee izvoene dijelove koda malo po ma-lo prevode u strojni kod uz sve vie i vie ukljuenih optimizacija.

Osim uinkovitog izvoenja bajtkoda i pruanja izolacije od stvarne platforme na kojoj seprogrsm izvodi, Javin virtualni stroj ima jo jednu vanu zadau: automatsko upravljanje me-morijom programa. Naime, programski jezik Java ne poznaje metodu za oslobaanje zauze-te memorije. Analizirajui pogreke koje programeri rade u programskim jezicima nie razinepoput programskog jezika C, Pascal i slinih ali i kod programskih jezika vie razine poputjezika C++ ustanovljeno je da velik niz pogreaka koje programeri rade spadaju u pogrekevezane uz loe upravljanje memorijom. S druge pak strane, takoer je ustanovljeno da uprogramima koji su korektni nezanemariv dio koda koji je napisan slui iskljuivo za uprav-ljanje memorijom -- zauzimanje memorije, provjeravanje treba li neki dio memorije oslobodi-ti te oslobaanje memorije. Kako bi jednim udarcem rijeila sve navedene probleme, Javazadau upravljanja memorijom prebacuje na Javin virtualni stroj i programera u potpunostioslobaa brige o oslobaanju memorije. Misao vodilja je pri tome vrlo jasna: umjesto da svakiprogramer za sebe u svakom svojem programu pie dijelove koda koji se brinu za oslobaa-nje memorije, napiimo to jednom direktno u virtualnom stroju i onemoguimo programeruda uope brine o tom zadatku.

Podsustav unutar Javinog virtualnog stroja koji se bavi ovim zadatkom zove se garbage col-lector. Specifikacija Javinog virtualnog stroja ne propisuje kako ovaj podsustav mora biti im-plementiran -- propisuje samo funkciju koju on treba ostvarivati. Dva su tipina naina izvo-enja ovakvog podsustava: brojanjem referenci ili pak periodikim zamrzavanjem programai praenjem ivih referenci. Meutim, svaka od ovih izvedbi, pa dapae i razliite izvedbe

Jezici podrani od JVM-a

6

unutar iste kategorije sustava nude razliito dinamiko ponaanje izvoenja programa. Sobzirom da u viedretvenom okruenju postoji itav niz problema koje treba uzeti u obziri nekako rijeiti te s obzirom da se ta rjeenja ponaaju razliito na sustavima koji ukupnoimaju malo memorije u odnosu na sustave koji ukupno imaju puno memorije odnosno nasustavima koji imaju jednu jezgru ili pak vie jezgri, danas je sasvim uobiajena situacijada Javin virtualni stroj dolazi s vie implementiranih strategija i da omoguava korisniku daprilikom pokretanja virtualnog stroja odabere i dodatno podesi strategiju koja e se koristiti.Bez dodatnih podeavanja virtualni stroj se pokree sa strategijom za koju je utvreno da uprosjeku radi dobro na relativno velikom broju razliitih programa.

Jezici podrani od JVM-aU posljednjih desetak godina broj jezika koji su podrani od strane JVM-a znaaj-no je narastao. Relativno iscrpan popis moe se pogledati na http://en.wikipedia.org/wi-ki/List_of_JVM_languages. Razloga za implementaciju ovakvih jezika je mnotvo, od kojihsu moda dva najvanija portabilnost te mogunost uporabe svih mehanizama koje Javinvirtualni stroj nudi, poev od ugraenog i vrlo kvalitetnog podsustava za automatsko uprav-ljanje memorijom pa do odline potpore za viedretvenost. U ovom kontekstu i portabilnostje izuzetno znaajna: osim to omoguava da se program napisan u nekom od jezika kojisu podrani na Javinom virtualnom stroju izvode na bilo kojoj platformi na kojoj postoji Javinvirtualni stroj, nudi se i vie -- takvi jezici esto mogu direktno komunicirati s dijelovima kodakoji su napisani u drugim jezicima to otvara vrlo zanimljive mogunosti za izradu aplikacija.

Kako je ovakvih jezika danas mnogo, u nastavku emo nabrojati samo neke od najintere-santnijih.

Popis drugih zanimljivijih jezika za Javin virtualni stroj

Rhino Implementacija jezika JavaScript. Izvorno implementirana od tvrtke Mozilla, bi-blioteka koja omoguava izvoenje programa pisanih u jeziku JavaScript na Ja-vinom virtualnom stroju danas je sastavni dio Javinog izvrnog okruenja. Stogaza njegovu uporabu nije potrebno nikakva dodatna instalacija.

U trenutku pisanja ovog teksta aktualna verzija jezika bila je 1.7R4. Stranica pro-jekta Rhino je https://developer.mozilla.org/en-US/docs/Rhino.

Scala Ovo je implementacija funkcijskog jezika koji se izvodi na Javinom virtualnomstroju. U posljednjih nekoliko godina ovaj je jezik postao poprilino rasprostranjento je vidljivo i iz niza napisanih knjiga koje ga opisuju.

U trenutku pisanja ovog teksta aktualna verzija jezika bila je 2.9.2. Stranica jezikaScala je http://www.scala-lang.org/.

Clojure Jezik Clojure jo je jedan funkcijski programski jezik za Javin virtualni stroj. Ovajjezik jedan je od dijalekata jezika Lisp koji sa sobom donosi bogat skup nepro-mjenjivih struktura podataka, a za potrebe izmjenjivih podataka nudi mehanizmepoput transakcijske memorije te reaktivnih agenata koji omoguavaju jednostav-nu izradu viedretvenih programa.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 1.4. Stranicajezika Clojure je http://clojure.org/.

JRuby Jezik JRuby predstavlja implementaciju jezika Ruby za Javin virtualni stroj. Ra-zvoj jezika Ruby zapoeo je oko 1995. godine; sam jezik nastao je kao spoj je-zika Perl, Smalltalk, Eiffel, Ada te Lisp.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 1.7.1. Stra-nica jezika JRuby je http://jruby.org/ dok se vie o originalnom jeziku Ruby moepronai na http://www.ruby-lang.org/en/.

Podrani tipovi podataka

7

Jython Jezik Jython predstavlja implementaciju jezika Python za Javin virtualni stroj.Jezik Python kroz posljednjih je nekoliko godina postao vrlo proiren i popularanprogramski jezik. Jedan od razloga tome lei u bogatstvu stilova programiranjai jezinih konstrukata koje ovaj jezik nudi programerima na uporabu. to se tieperformansi programa pisanih u ovom jeziku, one esto nisu ba na zavidnojrazini, no u mnotvu situacija kada to nije od presudne vanosti ovaj se jezikpokazuje kao odlian izbor.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 2.5.3. Stra-nica jezika Jython je http://www.jython.org/. Zainteresirani itatelji upuuju se ina knjigu o ovom jeziku koja je javno dostupna direktno na Internetu [8.]

Groovy Groovy predstavlja implementaciju dinamikog jezika za Javin virtualni stroj. Ovajjezik takoer je u posljednjih nekoliko godina postao dosta popularan i ima nizprimjena te poprilian broj knjiga koje su o njemu napisane.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 2.0. Stranicajezika Groovy je http://groovy.codehaus.org/.

Jaskell Jaskell predstavlja implementaciju jednog od vrlo popularnih funkcijskih jezika:jezika Haskell. Jezik nudi statiko izvoenje tipova i niz drugih funkcijskih kons-trukata.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 1.0. Stranicajezika Jaskell je http://jaskell.codehaus.org/.

Yeti Iskreno govorei, jezik Yeti ne spada meu ba popularnije jezike za Javin vir-tualni stroj; ovdje ga spominjemo naprosto stoga to predstavlja implementacijujednog od vrlo zanimljivih funkcijskih jezika: jezika ML. Jezik nudi statiko zaklju-ivanje o tipovima Hindley-Milnerovim algoritmom, curryjev oblik funkcija, podu-daranje uzoraka, monadike kombinatore, funkcije vie reda i slino.

U trenutku pisanja ovog teksta aktualna stabilna verzija jezika bila je 0.9.7. Stra-nica jezika Yeti je http://mth.github.com/yeti/.

Podrani tipovi podatakaJava je objektno-orijentirani programski jezik. Pri prvom susretu s Javom stoga mnogi pret-postave da u Javi postoji tip podataka koji predstavlja objekte. I nakon toga krenu bespo-trebne rasprave o tome kako se u Javi obavlja prijenos parametara pri pozivu metoda: povrijednosti ili po referenci (ako u ovom trenutku neto od ove reenice nije jasno -- to je OK).Da bismo odmah u poetku razrijeili ove probleme, idemo odmah jasno definirati ime toJava raspolae.

Prema slubenoj specifikaciji jezika Java SE 7 [6], programski jezik Java prepoznaje dvijevrste podataka: primitivne tipove te reference; i to je to -- nita manje i nita vie. Primitivnitipovi podataka su numerike vrijednosti, vrijednosti istinitosti te znakovi. Postoji osam pri-mitivnih tipova podataka i oni su opisani u tablici Tablica1.1. Primitivne vrijednosti moemopodijeliti u numerike te tip za prikaz istinitosti. Numerike tipove moemo podijeliti u cjelo-brojne (byte, short, int, long, char) i decimalne (float i double). Za prikaz istinitosti definiranje samo jedan tip: boolean.

Tablica1.1.Primitivni tipovi u programskom jeziku Java

Tip Opisbyte Predstavlja cijeli broj iji je raspon ogranien na interval od -128 do +127.

Konceptualno, radi se o 8-bitnom cijelom broju s predznakom koji koristi dvoj-ni komplement.

Podrani tipovi podataka

8

Tip Opisshort Predstavlja cijeli broj iji je raspon ogranien na interval od -32768 do

+32767. Konceptualno, radi se o 16-bitnom cijelom broju s predznakom kojikoristi dvojni komplement.

int Predstavlja cijeli broj iji je raspon ogranien na interval od -2,147,483,648do +2,147,483,647. Konceptualno, radi se o 32-bitnom cijelom broju s pred-znakom koji koristi dvojni komplement.

long Predstavlja cijeli broj iji je raspon ogranien na interval od-9,223,372,036,854,775,808 do +9,223,372,036,854,775,807. Konceptual-no, radi se o 64-bitnom cijelom broju s predznakom koji koristi dvojni kom-plement.

float Predstavlja decimalni broj skromne preciznosti. Konceptualno, odgovaraspecifikaciji IEEE 754 za decimalne brojeva jednostruke preciznosti (troi se32 bita odnosno 4 okteta za svaku vrijednost).

double Predstavlja decimalni broj skromne preciznosti. Konceptualno, odgovaraspecifikaciji IEEE 754 za decimalne brojeva dvostruke preciznosti (troi se64 bita odnosno 8 okteta za svaku vrijednost).

boolean Predstavlja tip podataka koji se koristi za prikaz istinitosti. Podatci ovog tipamogu poprimiti jednu od dviju vrijednosti: true te false.

char Predstavlja tip podataka koji se koristi za prikaz jednog znaka. Konceptualno,to je cijeli 16-bitni broj bez predznaka, tako da su legalne vrijednosti cijelibrojevi iz raspona od 0 do 65535, ili alternativno od '\u0000' do '\uffff'. Ovoje znaajna razlika u odnosu na programski jezik C kod kojeg je jedan znakkoristio za pohranu jedan oktet. Ova razlika uvedena je kako bi se jezikuomoguilo da transparentno radi s velikim brojem razliitih znakova koristeipri tome Unicode specifikaciju [1].

Nad cjelobrojnim tipovima podataka mogue je obavljati niz operacija. Operatori < (manje), (vee), >= (vee ili jednako), == (jednako) te != (razliito) omogu-avaju usporedbu dviju vrijednosti. Postoje unarni operatori + i - te binarni operatori + (zbra-janje), - (oduzimanje), % (ostatak cjelobrojnog dijeljenja), * (mnoenje) i / (dijeljenje) kojiomoguavaju provoenje aritmetikih operacija. Na raspolaganju su prefiks i postfiks inaiceoperatora za inkrement vrijednosti (++) te operatora za dekrement vrijednosti (--). Postojetri operatora posmaka: > koji predstavlja aritmetiki po-smak u desno (uva se predznak) te >>> koji predstavlja logiki posmak u desno (upranjenomjesto uvijek se puni s vrijednou 0). Konano, na raspolaganju su jo i unarni operator bi-tovnog komplementa (~) koji u binarnom zapisu vrijednosti komplementira svaki bit zasebnote binarni bitovni operatori za provoenje operacija I (&), ILI (|) te iskljuivo ILI (^). Konano,ova vrsta podataka moe se nai kao operand ternarnog operatora odabira (? :).

Prilikom provoenja operacija ako je barem jedan od argumenata tipa long, tada se operacijaprovodi (i rezultira s) tipom long; u suprotnom, operacija se provodi u domeni tipa int i rezultatje tog tipa (neovisno o tome jesu li operandi takoer bili tog tipa ili nekog "jednostavnijeg",poput byte).

Skup operatora koji su podrani nad decimalnim brojevima neto je manji u odnosu na opera-cije podrane nad cijelobrojnim tipovima jer pojedine operacije u ovoj domeni nemaju smisla;tako primjerice ne postoje operatori posmaka, binarnog komplementa te bitovne operacije.Dodatno, decimalni brojevi mogu poprimiti i neke specifine vrijednosti kojima se signalizirada je vrijednost jednaka pozitivnoj ili negativnoj beskonanosti, ili pak da nije valjani broj (npr.rezultat dijeljenja 0/0).

Tip boolean podrava najmanji skup operatora koji mogu djelovati nad njime. Tu su operatoriza ispitivanje jednakosti dviju vrijednosti (== te !=), unarni operator komplementa vrijednosti(!), binarni logiki operatori &, | te ^), uvjetni logiki operatori (&& i ||) te ternarni opera-tor odabira (? :). Uvjetni logiki operatori argumente raunaju samo ako je to potrebno.

Primjeri literala

9

Primjerice, ako imamo izraz izraz1 || izraz2, izraz izraz2 e se raunati samo akoizraun izraza izraz1 rezultira s vrijednou false. Ako izraun izraza izraz1 rezultiras vrijednou true, tada e i vrijednost logike operacije ILI rezultirati s vrijednou truei desna strana operatora se uope nee raunati. To je pak zgodno jer omoguava pisanjekoda poput car==null || car.emptyTank() koji e se razrjeiti u vrijednost true bi-lo u sluaju da je varijabla car inicijalizirana s null referencom, bilo da pokazuje na nekiprimjerak automobila za koji metoda emptyTank vraa vrijednost true. Uporaba klasinoglogikog operatora | u ovom kontekstu rezultirala bi izazivanjem pogreke u sluaju da je prviuvijet ispunjen jer se tada nad takvom varijablom metoda emptyTank ne bi smjela pozvatipa bismo trebali pisati kompliciraniji kod koji bi proveo ovo ispitivanje.

Primjeri literalaZa iscrpan i potpun opis svih naina na koji se mogu pisati literali pojedinih tipova itateljse upuuje na [6]. U nastavku emo prikazati samo nekoliko primjera koji e biti dovoljni zadaljnje praenje ove knjige.

Tip byte: (byte)12, (byte)-74. Nuna je uporaba operatora ukalupljivanja (engl. castoperator).

Tip short: (short)12, (short)-74. Nuna je uporaba operatora ukalupljivanja (engl.cast operator).

Tip int: 12, -74, 0x2f3 (zadano heksadekadski), 0b01001110 (zadano binarnim zapi-som), 02731 (zadano oktalno). Literal se tumai kao heksadekadski ako zapoinje s 0xa kao binarni ako zapoinje s 0b; ako zapoinje s 0 nakon ega slijede brojevi, tumai sekao oktalni. Kako bi se pospjeila itljivost, izmeu znamenaka moe se umetnuti jednaili vie podvlaka: 123_451.

Tip long: 12L, -74L. Osim navedenog, mogu se zadavati i binarni, oktalni te heksadekad-ski oblici pri emu na kraju moraju imati slovo L; primjerice: 0x7eab3281552fL.

Tip float: 12.0f, -74.0f, 3f, 2.f, 21.3e+2f, 21.3e-3f. Nuna je uporaba slova f nakraju.

Tip double: 12.0, -74.0, 3d, 2., 21.3e+2, 21.3e-3. Sufiks d nije obavezan; nuno gaje pisati samo kada bi bez njega literal bio protumaen drugaije; primjerice 3 je literal tipaint dok je 3d literal tipa double.

Tip char: 'A', '\u0041', '\t', '\\'. Uporaba markera \u omoguava unos 4 heksa-dekadske znamenke kojima je jednoznano odreen jedan znak. Prilikom tumaenja une-seng broja Java koristi UTF-16 specifikaciju. Heksadekadska sekvenca 0041 predstavljadekadsku vrijednost 65 odnosno veliko slovo A. Znak \ uvijek uvodi posebno interpretira-nje onoga to slijedi; ako je sljedee slovo u, oekuje se heksadekadska sekvenca koja uskladu sa specifikacijom UTF-16 odreuje o kojem se znaku radi. Meutim, druga slovaomoguavaju unos drugih esto koritenih znakova; primjerice, slijed \t tumai se kaoznak tab, slijed \n tumai se kao znak za prelazak u novi red (tipino separator redaka utekstovnim datotekama) a slijed \' se tumai kao znak '. Ako ba elimo unijeti znak \,tada moramo posegnuti za slijedom \\ koji e se protumaiti upravo kao jedan znak \.

Za tip boolean mogue su samo dvije vrijednosti i obje su kljune rijei: true odnosnofalse.

Za sve reference postoji samo jedan literal: null.

StringoviPrimjetite da do sada nita nismo govorili o stringovima. Programski jezik Java ne poznajestringove kao primitivne tipove podataka. Svaki string pohranjuje se kao primjerak razreda

Primjeri literala

10

java.lang.String (tj. razreda String smjetenog u paket java.lang. Meutim, kako bi se progra-merima ponudio to je mogue jednostavniji i intuitivniji rad sa stringovima, od Java prevo-dioca se oekuje da stringove u izvornom kodu prepoznaje i po potrebi automatski generirakod koji e stvoriti potrebne objekte. String literali se, kao i u veini drugih programskih jezi-ka piu pod dvostrukim navodnicima. Tako su primjeri stringova: "" (prazan string tj. stringduljine 0), "Hello world!" (string koji sadri 12 znakova), "First line.\nSecondline." (string koji sadri dva retka; \n je sekvenca koja predstavlja prijelom retka i tumaise kao jedan ascii znak ija je vrijednost 10). Jezini prevodioc dopustit e nam i spajanjevie stringova operatorom +, pa tako moemo pisati:

String s = "Ovo " + "je " + "tekst";

to e rezultirati jednim stringom sadraja:

"Ovo je tekst."

Operator plus, ako se koristi u kontekstu stringova, moe posluiti i za pretvorbu drugih tipovapodataka u stringove. Primjerice,

String s = "Vidim " + 15 + "zeeva";

rezultirati e jednim stringom sadraja:

"Vidim 15 zeeva."

Tijekom prevoenja, 15 je literal tipa int; meutim, konkatenacijom sa stringom on se prevodiu string reprezentaciju. Vie o ovome e biti govora neto kasnije. Konkatenacija ne zahtjevada se navode samo literali. I sljedei isjeak koda e raditi prema oekivanjima.

int n = 15;String s = "Vidim " + n + "zeeva";

Rezultat e biti jednak rezultatu prethodnog primjera.

S obzirom da su stringovi objekti, nad svakim stringom programerima na raspolaganju stojiniz metoda koje je mogue pozvati kako bi se dobile neke informacije o stringu ili kako bi seprovele odreene operacije. Evo jednog primjera.

String poruka = "Doao sam u grad Zagreb.";int duljina = poruka.length();String velika = poruka.toUpperCase();String grad = poruka.substring(17,23);

Vrijednost varijable duljina postat e 24 -- metoda .length() vratit e duljinu tekstanad kojim je pozvana, izraeno u znakovima, to je u ovom sluaju 24.Varijable velika predstavljat e novi string u kojem su sva slova velika. Metoda .to-UpperCase() stvara novi string koji je sadrajno jednak stringu nad kojim je pozvanauz razliku da e sva mala slova u vraenom stringu biti zamijenjena velikim slovima.Varijable grad predstavljat e novi string Zagreb. Metoda .substring() pozvanauz dva argumenta vraa novi string koji predstavlja podniz originalnog stringa; prvi ar-gument odreuje poziciju znaka s kojim zapoinje taj podniz a drugi argument odreujepoziciju prvog znaka koji vie nije dio vraenog podniza.

Prilikom rada sa stringovima vano je zapamtiti da su u Javi stringovi nepromjenjivi (engl.immutable). Jednom stvoreni string nemogue je promijeniti, i metode koje naoko ine nekeizmjene (poput metode .toUpperCase() ili pak metode .replace(...)) zapravo vraa-ju novi string -- originalni string se pri tome ne mijenja. Zahvaljujui takvom radu, neke seoperacije u Javi mogu izvesti izuzetno efikasno, poput operacije .substring(...) koja umemoriji nee raditi novu kopiju sadraja ve e doslovno samo zapamtiti poziciju poetkai kraja u originalnom stringu.

Inicijalizacija vrijednosti

11

Kako bi se podrala nepromjenjivost stringova, Java programerima ne omoguava direktanpristup memorijskom spremniku u kojem se uva sadraj stringa. Meutim, nudi se metodakojom se mogu dohvaati (ali ne i mijenjati) pojedini znakovi. Evo primjera.

String poruka = "Moje ime je Ivana.";char prviZnak = poruka.charAt(0);char sedmiZnak = poruka.charAt(6);

Varijabla prviZnak dobit e vrijednost 'M'Varijabla sedmiZnak dobit e vrijednost 'm'

Argument metode charAt(...) je indeks znaka koji elimo dohvatiti. Znakovi su pri tomeindeksirani od vrijednosti 0.

Jedan od naina stvaranja novih stringova je i direktno predavanjem polja znakova koje pred-stavlja sadraj stringa. Evo primjera.

char sadrzaj[] = {'Z', 'a', 'g', 'r', 'e', 'b'};String grad = new String(sadrzaj);sadrzaj[1] = 'B';

Stvara se novi string iji je sadraj "Zagreb". Meutim, string koji nastaje kao internispremnik teksta ne koristi predano polje ve radi svoju vlastitu kopiju.Naknadna promjena elemenata polja sadrzaj stoga ne mijenja prethodno stvorenistring -- njegov sadraj je i dalje "Zagreb".

Inicijalizacija vrijednostiSpecifikacija programskog jezika Java garantira da e sve varijable, osim lokalnih kao i svielementi polja automatski biti inicijalizirani na poetne vrijednosti. Za sve tipove podatakakoje Java podrava vrijednosti su navedene u nastavku.

Za tip byte poetna vrijednost je nula, odnosno (byte)0.

Za tip short poetna vrijednost je nula, odnosno (short)0.

Za tip int poetna vrijednost je nula, odnosno 0.

Za tip long poetna vrijednost je nula, odnosno 0L.

Za tip float poetna vrijednost je nula, odnosno 0.0f.

Za tip double poetna vrijednost je nula, odnosno 0.0d.

Za tip char poetna vrijednost je nula, odnosno '\u0000'.

Za tip boolean poetna vrijednost je nula, odnosno false.

Za sve reference poetna vrijednost je null.

Poetne vrijednosti automatski se ne dodjeljuju lokalnim varijablama (lokalne varijable suvarijable koje su deklarirane unutar funkcija). Svim lokalnim varijablama vrijednost treba do-dijeliti eksplicitno prije prvog itanja njihove vrijednosti.

Pretvorbe primitivnih tipova u stringZa pretvorbu osnovnih tipova podataka u string, u Javi nam na raspolaganju stoji ve nizgotovih metoda. U okviru razreda String postoji porodica metoda .valueOf(...) kojemogu primaju vrijednosti primitivnih tipova a generiraju tekstovne prikaze istih. Evo primjera.

char c = 'A';

Omotai primitivnih tipova

12

double d = 1.1;float f = 4.25f;int n = 125;String sc = String.valueOf(c); // Rezultirat e s "A"String sd = String.valueOf(d); // Rezultirat e s "1.1"String sf = String.valueOf(f); // Rezultirat e s "4.25"String sn = String.valueOf(n); // Rezultirat e s "125"

Omotai primitivnih tipovaU programskom jeziku Java, za sve primitivne tipove definirani su i razredi-omotai (engl.wrappers). Tako postoje razredi Byte, Short, Integer, Long, Float, Double te Boole-an. Svaki razred omota korisnicima nudi funkcionalnost pretvorbe primitivne vrijednosti ustring, pretvorbe stringa u primitivnu vrijednost te jo niz drugih korisnih metoda. Evo neko-liko primjera koji koriste razred Integer.

int broj = 125;String sBroj = "517";

int vrijednost = Integer.parseInt(sBroj); // 517String tekst = Integer.toString(broj); // "125"String tekst8 = Integer.toString(broj, 8); // "175" (u bazi 8)String tekstBin = Integer.toBinaryString(broj); // "1111101"String tekstHex = Integer.toHexString(broj); // "7D"

U prethodnom primjeru koristili smo metode razreda Integer kako bismo obavljali konver-zije izmeu stringa i primitivne vrijednosti. Omotai su, meutim, prikladni i za reprezentacijuprimitivnih vrijednosti. Opet emo dati primjer kroz razred Integer.

int broj1 = 50;int broj2 = 200;

Integer b1 = Integer.valueOf(broj1);Integer b2 = Integer.valueOf(broj2);

boolean manji = b1.compareTo(b2) < 0;int suma = b1.intValue() + b2.intValue();int razlika = b1 - b2;

String b2KaoString = b2.toString(); // "200"

Za razliku od primitivnih tipova, primjerci razreda omotaa su upravo to -- primjerci razreda,odnosno objekti. U prethodnom primjeru e b1 predstavljati objekt koji enkapsulira cijeli broj50 dok e b2 predstavljati objekt koji enkapsulira cijeli broj 200. S obzirom da su to objekti,nad njima emo moi pozivati podrane metode, poput metode compareTo(...) koja eusporediti vrijednost broja koji enkapsulira omota nad kojim smo pozvali metodu s vrijed-nou broja koji enkapsulira omota koji predajemo kao argument, i koja e vratiti vrijednost-1 ako je prva vrijednost manja od druge.

Omotai vrijednosti, ba kao i stringovi, u Javi predstavljaju nepromjenjive objekte. Stoga nu-de samo metodu kojom je mogue dohvatiti trenutnu primitivnu vrijednost (ali je nije moguepromijeniti). Primjer je metoda .intValue() kod razreda Integer koja vraa primitivnuvrijednost kao tip int. Java prevodioc e za programera automatski pozivati te metode gdjeje potrebno kako bi kod uinio kompaktnijim. U prethodnom primjeru to je vidljivo u retku ukojem raunamo

int razlika = b1 - b2;

to e se efektivno prevesti u kod

Uvjetno izvoenje, pet-lje i decimalni brojevi

13

int razlika = b1.intValue() - b2.intValue();

bez ikakve intervencije od programera.

Stvaranje primjeraka omotaa uobiajeno je mogue obaviti na dva naina: direktnim pozi-vom metode koja u memoriji zauzima mjesto za novi primjerak razreda (tzv. konstruktor raz-reda), ili pak pozivom metode .valueOf(...) koju nude svi omotai. Primjer je prikazanu nastavku.

Integer i1 = new Integer(17);Integer i2 = new Integer(17);Integer i3 = Integer.valueOf(17);Integer i4 = Integer.valueOf(17);

Prva dva retka pokazuju stvaranje dva primjerka omotaa oko primitivne vrijednosti 17. Svakipoziv zauzet e novu koliinu memorije za objekt koji, zapravo, predstavlja istu vrijednost.Poziv metode .valueOf(...) omoguava programskom jeziku Java da, gdje je to prik-ladno, privremeno interno pohrani (keira) ve stvorene objekte te umjesto stvaranja novihobjekata vraa objekte iz prirunog spremnika (kea). Primjerice, uobiajene implementacijeinterno uvaju primjerke razreda Integer za primitivne vrijednosti od -128 do 127 pa eopetovani pozivi metode za istu vrijednost iz tog raspona uvijek vratiti isti, unaprijed alociraniobjekt. Uoimo da je to mogue jer omotai predstavljaju nepromijenjive objekte pa je sigur-no vraati isti objekt vie puta bez bojazni da e se pohranjena vrijednost negdje promijeniti.U prethodnom primjeru stoga e i3 i i4 predstavljati identian objekt u memoriji.

Uvjetno izvoenje, petlje i decimalni brojeviU programskom jeziku Java za uvjetno izvoenje koda na raspolaganju nam stoji if-elseif-...-else if-else konstrukt. Evo nekoliko primjera uporabe. Prvi primjer ilustrira kod kojiispituje je li sadraj varijable x neparan i ako je, uveava sadraj varijable broj za jedan.

int broj = 0;int x = 5;if(x % 2 != 0) { broj++;}

Java je strogo tipizirani programski jezik. Posljedica je da se na mjestu gdje se oekujevrijednost tipa boolean ne moe pojaviti nita drugo. Primjerice, u programskom jeziku Cbilo bi legalno napisati:

if(x % 2) { broj++;}

to u Javi, meutim, nee proi. Evo sloenijeg primjera koji ilustrira program koji e, ovisnoo ostatku cjelobrojnog dijeljenja broja x s etiri uveati sadrat varijable broj za razliiteiznose.

int broj = 0;int x = 5;if(x % 4 == 0) { broj++;} else if(x % 4 == 1) { broj += 17;} else if(x % 4 == 2) { broj += 6;} else {


14

broj += 14;}

Umjesto viestrukog ispitivanja naredbom if, isto smo mogli postii konciznije uporabomnaredbe switch kako je prikazano u nastavku.

int broj = 0;int x = 5;switch(x % 2) { case 0: broj++; break; case 1: broj += 17; break; case 2: broj += 6; break; default: broj += 14; break;}

Primjetimo usput da opisano ispitivanje radi korektno za x>=0. U sluaju da je sadraj va-rijable x negativan, ostatci cjelobrojnog dijeljenja e takoer biti negativni to treba uzeti uobzir ako je takva situacija mogua.

Osim nad numerikim i logikim tipovima podataka, od verzije 7 programskog jezika Javanaredba switch podrava i ispitivanje stringova, pa je sljedei primjer korektan.

int broj = 0;String grad = "Zagreb";switch(grad) { case "Bjelovar": broj++; break; case "Split": broj += 2; break; case "Zagreb": broj += 3; break; default: broj += 4; break;}

Od naredbi za ponavljanje, u Javi moemo koristiti naredbu for, while te do-while. Pre-skakanje izvoenja ostatka trenutne iteracije postie se naredbom continue a kompletnoprekidanje iteriranja naredbom break. Pogledajmo naprije primjer uporabe petlje for.

int suma = 0;int[] polje = {1, 4, 7, 11, 13, 21};for(int i = 0; i < polje.length; i++) { if(polje[i] == 4) { continue; } if(polje[i] > 10) { break;


15

} suma += polje[i];}

Uz pretpostavku da je zadano polje sortirano, napisani program rauna sumu elemenatapolja koji nisu vei od 10 i koji su razliiti od 4. Tako naredba continue preskae auriranjesume ako je trenutni element jednak 4 a naredba break prekida zbrajanje im doe prvielement koji je vei od 10. Za navedeni primjer, sadraj varijable suma na kraju e biti jednak8.

Prethodni primjer mogli smo napisati i na sljedei nain.

int suma = 0;int[] polje = {1, 4, 7, 11, 13, 21};for(int i = 0, granica = polje.length; i < granica; i++) { if(polje[i] == 4) { continue; } if(polje[i] > 10) { break; } suma += polje[i];}

Umjesto da se na kraju svake iteracije nanovo dohvaa vrijednost polje.length, tu smovrijednost dohvatili jednom na ulasku u petlju, pohranili smo je u pomonu varijablu koju smonazvali granica i potom na kraju svake iteracije dohvaamo tu vrijednost. Kod pristupanjaveliini polja, ovo nee napraviti veliku razliku u brzini izvoenja koda, no da smo u uvjetu zaprekid imali poziv neke funkcije koja bi vraala primjerice veliinu kolekcije po kojoj prolazimo,razlika izmeu jednog poziva i viestrukih poziva mogla bi znaajnije utjecati na performanseprograma.

Poevi od Jave verzije 5, u jezik je uvedena potpora za jo jedan oblik petlje for koji je udrugim jezicima poznat pod nazivom foreach. Imamo li, primjerice, polje (ili neku kolekciju,to emo vidjeti kasnije), sve elemente moemo obii kako je prikazano u sljedeem primjeru.

int[] polje = {1, 4, 7, 11, 13, 21};for(int element : polje) { System.out.println("Trenutni element je: " + element);}

Ovaj obilazak ekvivalentan je obilasku prikazanom u nastavku.

int[] polje = {1, 4, 7, 11, 13, 21};for(int i = 0, granica = polje.length; i < granica; i++) { int element = polje[i]; System.out.println("Trenutni element je: " + element);}

Prednost kraeg oblika jest to je koncizniji -- ne trebamo sami stvarati pomonu varijablukoja e se koristiti kao indeks i ne trebamo sami dohvaati vrijednost pojedinog elementa ipohranjivati je u novu pomonu varijablu. Umjesto toga, moemo napisati krai oblik i pustitiJava-prevodilac da za nas izgenerira ekvivalentni kod. Pri tome u petlji for samo deklarira-mo tip varijable koji odgovara tipu elemenata iz polja (ili kolekcije), definiramo naziv lokalnevarijable koja e poprimati sve vrijednosti redom te nakon dvotoke dajemo polje (ili kolekciju)po kojem treba obii. Ovu jezinu konstrukciju esto itamo ovako: za int element u polje.

Naredbe continue i break mogu imati i dodatni argument (labelu) koji odreuje petlju nakoju se naredba odnosi. Evo primjera. Pretpostavimo da imamo nesortirano polje brojeva


16

te da trebamo utvrditi postoji li u tom polju duplikata. Oslanjajui se na osnovnu uporabunaredbe break, taj bismo kod mogli napisati na sljedei nain.

long[] polje = {1, 4, 7, 11, 13, 4, 21};boolean imaDuplikata = false;for(int i = 0; i < polje.length; i++) { long element1 = polje[i]; for(int j = i+1; j < polje.length; j++) { long element2 = polje[j]; if(i == j) { continue; } if(element1 == element2) { imaDuplikata = true; break; } } if(imaDuplikata) { break; }}System.out.println("Pronaeni su duplikati: "+ imaDuplikata);

Ne razmiljajui sada o efikasnosti izvoenja prethodnog koda, uoimo da imamo dvije ug-nijeene for-petlje. Vanjska petlja ide element po element polja, te unutarnja koja za svakifiksirani element ponovno prolazi kroz polje i provjerava ima li jo na kojoj lokaciji upravotakav element.U sluaju da je takav element pronaen, idealno bi bilo nakon auriranja zas-tavice imaDuplikata prekinuti obje petlje: i unutarnju i vanjsku. Meutim, koristei osnovnioblik naredbe break to nije mogue, pa se nakon unutarnje petlje provjerava je li postavljenazastavica imaDuplikata i ako je, prekida se i vanjska petlja novom naredbom break.

Uporabom labela, ovo se moe rijeiti jednostavnije. Vanjskoj petlji dat emo naziv (labelu)"Vanjska". Potom u unutarnjoj petlji naredbi break moemo predati tu labelu ime e nared-ba prekinuti i unutarnju i vanjsku petlju. Evo koda.

long[] polje = {1, 4, 7, 11, 13, 4, 21}; boolean imaDuplikata = false;Vanjska: for(int i = 0; i < polje.length; i++) { long element1 = polje[i]; for(int j = i+1; j < polje.length; j++) { long element2 = polje[j]; if(i == j) { continue; } if(element1 == element2) { imaDuplikata = true; break Vanjska; } } } System.out.println( "Pronaeni su duplikati: "+ imaDuplikata );

Pogledajmo sada i primjer uporabe petlje while.

int suma = 0;int[] polje = {1, 4, 7, 11, 13, 21};int i = 0;


17

while(i < polje.length) { if(polje[i] > 10) { break; } suma += polje[i]; i++;}

Slino moemo postii i do-while konstruktom.

int suma = 0;int[] polje = {1, 4, 7, 11, 13, 21};int i = 0;do { if(polje[i] > 10) { break; } suma += polje[i]; i++;} while(i < polje.length);

Treba meutim pripaziti na osnovnu razliku izmeu ove dvije naredbe. Naredba do-whilesignurno barem jednom ulazi u tijelo petlje pa bi prethodni primjer mogao neslavno zavritiako polje nema barem jedan element. Stoga se posljednji oblik koristi kada je na drugi nainve osigurano da e prvi prolaz sigurno zavriti korektno.

Konano, u okviru ovog podpoglavlja osvrnut emo se i na pisanje koda koji koristi operator== za utvrivanje ekvivalencije. Vano je zapamtiti da taj operator uvijek usporeuje vrijed-nost primitivnih tipova podataka. Sjetimo se, u javi su primitivni tipovi podataka numeriki,logiki te reference. etvrto ne postoji. Posljedica toga je da sljedei kod nee raditi onakokako bi poetnici to oekivali.

String prvi = new String("Zagreb");String drugi = new String("Zagreb");if(prvi == drugi) { System.out.println("Jednaki su!");} else { System.out.println("Nisu jednaki!");}

Rezultat e biti ispis

Nisu jednaki!

. Naime, iako bi na prvu mnogi rekli da su varijable prvi i drugi stringovi, one to nisu: tesu varijable po tipu reference na dva objekta koja predstavljaju stringove. Operator new jeoperator koji u memoriji zauzima mjesto za novi objekt i potom ga inicijalizira. S obzirom dau prva dva retka programa postoje dva poziva operatora new, jasno je da e rezultat biti dvaobjekta u memoriji na razliitim memorijskim lokacijama. Operator == usporeuje primitivnevrijednosti -- u ovom sluaju usporeuje dvije reference. Rezultat e biti true ako i samoako te dvije reference pokazuju na isti objekt u memoriji. Kako to ovdje nije sluaj, rezultatusporedbe e biti false i u naredbi if izvrit e se kod zadan u else dijelu.

Druga vana napomena odnosi se na usporedbu decimalnih brojeva. Za usporedbu decimal-nih brojeva nikada nije dobro koristiti operator ==. Naime, aritmetika s decimalnim brojeva uJavi je aritmetika s ogranienom preciznou. Pogledajmo naprije primjer 1.1


18

Primjer 1.1. Ilustracija raunanja s ogranienom preciznou teusporedba rezultata

1 public static void main(String[] args) { 2 double a = 1000; 3 double b = 7; 4 double c = Math.PI; 5 6 double rez1 = prviNacin(a, b, c); 7 double rez2 = drugiNacin(a, b, c); 8 9 if(rez1==rez2) { 10 System.out.println("Isti su."); 11 } else { 12 System.out.println("Nisu isti. Razlika je: " + (rez1-rez2)); 13 } 14 } 15 16 public static double prviNacin(double a, double b, double c) { 17 return (a + b + c) / 7; 18 } 19 20 public static double drugiNacin(double a, double b, double c) { 21 return a/7 + b/7 + c/7; 22 }

Ovaj kod predstavlja isjeak programa koji na dva naina rauna isti izraz. Metoda prvi-Nacin rauna izraz:

dok metoda drugiNacin rauna izraz:

Uvaavajui matematika znanja s kojima vladamo, znamo da bi ta dva izraza trebala pred-stavljati isto, odnosno znamo da bi trebalo vrijediti:

to je pak motivacija da za ispitivanje jednakosti koristimo operator == kako je to prikazano uretku 9 isjeka koda prikazanog na ispisu 1.1. Naalost, u stvarnosti, ovaj bi program ispisao:

Nisu isti. Razlika je: -2.8421709430404007E-14.

Razlog nastanka ove razlike je injenica da su tipovi podataka double i float tipovi zaprikaz vrijednost decimalnih brojeva do na unaprijed odreenu preciznost, to znai da se dioinformacije gubi. Tada vie nije nebitno hoemo li izraz izraunati tako da najprije izraunamosumu sva tri broja i potom je podijelimo sa sedam, ili emo najprije raunati sedmine pojedinihpribrojnika i potom ih pribrajati. Da je tome tako, upravo nam demonstrira prethodni primjer.

Upravo zbog ograniene preciznosti kojom se pohranjuju decimalni brojevi vano je za uspo-redbu decimalnih brojeva ne koristiti operator == ve se dogovoriti o dozvoljenom odstupa-nju uz koje emo brojeve ipak smatrati jednakima i potom provjeriti kakav je apsolutni iznosnjihove razlike s obzirom na dogovoreno doputeno odstupanje. Ispravan nain usporedbe"jednakosti" decimalnih brojeva prikazuje primjer 1.2.


19

Primjer1.2.Usporedba jednakosti decimalnih brojeva

1 public static void main(String[] args) { 2 double a = 1000; 3 double b = 7; 4 double c = Math.PI; 5 6 double rez1 = prviNacin(a, b, c); 7 double rez2 = drugiNacin(a, b, c); 8 9 if(Math.abs(rez1-rez2) < 1E-8) { 10 System.out.println("Isti su."); 11 } else { 12 System.out.println("Nisu isti. Razlika je: " + (rez1-rez2)); 13 } 14 } 15 16 public static double prviNacin(double a, double b, double c) { 17 return (a + b + c) / 7; 18 } 19 20 public static double drugiNacin(double a, double b, double c) { 21 return a/7 + b/7 + c/7; 22 }

21

Poglavlje2.Prvi Java programNakon to smo se upoznali s osnovnim pojmovima o platformi Java, pogledajmo koji sukoraci potrebni kako bismo doli do prvog izvrnog programa napisanog u Javi. Fokus ovogpoglavlja su osnove -- radit emo bez razvojnih okruenja i "magije" koju oni donose sasobom. Ideja je razumjeti to se dogaa u pozadini svih tih procesa kako bismo kasnije moglidjelotvornije koristiti razvojna okruenja.

PreduvjetiDa biste mogli isprobati primjere navedene u ovom poglavlju, na raunalu trebateimati instaliran JDK te neki ureiva teksta. Za kratku uputu o instalaciji JDK-apogledajte dodatak A. Radite li na operacijskom sustavu Windows, preporukaje da koristite ureiva poput programa Notepad++ koji e Vam omoguiti daizvorne programe spremite uporabom kodne stranice UTF-8 bez BOM markera.Na modernijim inaicama operacijskog sustava Linux moete koristiti bilo kojiureiva teksta jer oni danas uobiajeno koriste UTF-8 za pohranu tekstova.

U izradu Java programa krenut emo s najjednostavnijim moguim primjerom: programomkoji e na zaslon ispisati poruku Hello, world! Uimo Javu!. Za potrebe ovog poglavljapretpostavit emo da e svi programi biti smjeteni na datotenom sustavu unutar vrnogpoddirektorija D:\javaproj. Ako se odluite za neku drugu lokaciju, obratite panju dana svim mjestima u nastavku tu stazu zamijenite stazom koju ste sami odabrali. Napravitenavedeni direktorij i unutar njega napravite direktorij projekt1. Potom se pozicionirajte unavedeni direktorij. Naredbe kojima ete to napraviti su sljedee.

D:\>mkdir javaprojD:\>cd javaprojD:\javaproj>mkdir projekt1D:\javaproj>cd projekt1D:\javaproj\projekt1>

Direktorij D:\javaproj\projekt1 posluit e nam kao vrni direktorij za izradu ovog jed-nostavnog programa. Unutar tog direktorija stvorit emo jo dva poddirektorija: src unutarkojeg emo smjestiti izvorni kod programa (engl. source files) te direktorij bin unutar kojegemo generirati izvrni kod programa. Potrebne naredbe prikazane su u nastavku.

D:\javaproj\projekt1>mkdir srcD:\javaproj\projekt1>mkdir bin

U ovom trenutku cjelokupna struktura direktorija koju smo pripremili trebala bi izgledati kakoje prikazano u nastavku.

D:\ +-- javaproj +-- projekt1 +-- src +-- bin

Program s kojim emo krenuti smjestit emo u datoteku HelloWorld.java iji je sadrajprikazan u primjeru 2.1. Datoteku je potrebno napraviti u direktoriju src pa u njegovom pod-direktoriju hr\fer\zemris\java\tecaj_1. Stvaranje cjelokupne podstrukture direktorijamogue je obaviti naredbom mkdir odjednom.

U ureivau teksta koji ete koristiti stvorite praznu datoteku hr\fer\zemris\ja-va\tecaj_1\HelloWorld.java i prepiite sadraj prikazan u primjeru 2.1. Datoteku oba-vezno pohranite koristei UTF-8 kodnu stranicu bez BOM-a.

22

Primjer2.1.Primjer programa napisanog u programskom jeziku Java

1 package hr.fer.zemris.java.tecaj_1;2 3 /**4 * Program ija je zadaa na ekran ispisati poruku5 * "Hello, world!".6 * 7 * @author Marko upi8 * @version 1.09 */10 public class HelloWorld {11 12 /**13 * Metoda koja se poziva prilikom pokretanja 14 * programa. Argumenti su objanjeni u nastavku.15 * 16 * @param args argumenti komandne linije. U ovom17 * primjeru se ne koriste.18 */ 19 public static void main(String[] args) {20 System.out.println("Hello, world! Uimo Javu!");21 }22 23 }24

Pogledajmo malo detaljnije primjer 2.1. Java je objektno orijentirani programski jezik; stogasu osnovni dijelovi svakog programa objekti. Primjer 2.1 ilustrira definiranje razreda Hel-loWorld. Definiranje novog razreda obavlja se uporabom kljune rijei class, to je vidljivou retku 10 gdje deklaracija zapoinje navoenjem modifikatora public, kljune rijei class,nazivom razreda koji se deklarira HelloWorld i otvorene vitiaste zagrade. Deklaracija raz-reda protee se sve do odgovarajue zatvorene vitiaste zagrade u retku 23.

UpozorenjeNaziv datoteke mora odgovarati nazivu razreda koji je definiran u datoteci. Pritome se mora paziti i na velika i mala slova, neovisno o tome je li datoteni sustavosjetljiv na velika i mala ili nije.

Da bi se programerima olakalo odabiranje smislenih imena razreda (a time i pisanje kvalitet-nijeg koda), Java omoguava smjetanje razreda u hijerarhijski definirane pakete. Na taj na-in programeru se omoguava da za pisanje novog programa ili biblioteke odabere novi paketi potom ne treba brinuti je li netko ve negdje u nekom drugom paketu napisao razred koji sezove jednako -- razredi koji nose isto ime ali su smjeteni u razliite pakete za programski je-zik Java nisu isti razredi i definiran je jasan skup pravila koji osiguravaju da se program moejednoznano pozvati i koristiti upravo one razrede koje je programer elio koristiti. U primje-ru 2.1 odabrali smo razred HelloWorld smjestiti u paket naziva hr.fer.zemris.java.tecaj_1.Ova odluka definirana je u retku 1 gdje nakon kljune rijei package slijedi odabrani nazivpaketa i nakon toga znak toka-zarez.

Konano, u razredu HelloWorld, poevi od retka 19, definirali smo jednu javnu statikumetodu imena main ija je definicija prikazana u nastavku.

public static void main(String[] args);

Koje je tono znaenje pojmova javnu statiku bit e objanjeno kasnije kada se malo boljeupoznamo s Javom i objektnim oblikovanjem. Ostanimo za sada na pojanjenju da metodamora biti javna i statika kako bi je virtualni stroj mogao pozvati kao poetnu toku izvoe-

Prevoenje programa

23

nja programa. Povratna vrijednost mora biti void te metoda mora deklarirati samo jedan ar-gument -- polje stringova preko kojeg e dobiti pristup argumentima koje je korisnik unio ukomandnu liniju prilikom pokretanja programa.

Primjer 2.1 ujedno ilustrira i uporabu komentara. Osim to se u Javi mogu koristiti uobiajenikomentari koji zapoinju s dvije kose crte i proteu se do kraja retka ili pak vielinijski ko-mentari koji zapoinju s /* i koji se proteu do prve pojave */, Java nam dozvoljava i uporabutakozvanih Javadoc komentara. Javadoc komentari su komentari ija je namjena omogui-ti automatsko generiranje dokumentacije iz izvornog koda. Ovu vrstu komentara prepoznatemo po tome to zapoinju s /** i tipino sadre posebne oznake koje zapoinju znakom @.U prikazanom primjeru tako imamo dokumentiran razred HelloWorld uz navoenje njego-ve svrhe, autora i verzije te imamo dokumentiranu metodu main pri emu je dat opis metodekao i opis njezinih parametara. Vie o ovome bit e rijei u nastavku.

Prevoenje programaPrevoenje izvornog programa u izvrni Java program obavlja se pozivom java prevodioca.Java prevodioc koji je dostupan u ukviru JDK-a poziva se naredbom javac. Zadat emosljedeu naredbu.

d:\javaproj\projekt1>javac -sourcepath src -d bin -encoding UTF-8 \ -deprecation -g:lines,vars,source \ src\hr\fer\zemris\java\tecaj_1\*.java

UpozorenjeS obzirom da naredba zahtjeva nekoliko argumenata, itav poziv ne stane ujedan redak te je za potrebe ispisa razlomljen u vie redaka. Na kraju svakogretka koji je slomljen dodan je znak \ koji oznaava prijelom -- prilikom unosanaredbe u naredbeni redak taj znak treba preskoiti.

Parametar -sourcepath koristi se kako bi se zadao direktorij koji sadri izvorne kodovei pripadnu strukturu poddirektorija koja odgovara razmjetaju razreda u pakete. U naemsluaju to je direktorij src. Parametar -d odreuje direktorij u koji e se smjestiti izvrnikodovi Java programa. Java prevodioc e prilikom prevoenja izvornih kodova programau direktoriju za smjetaj izvrnih kodova rekonstruirati strukturu direktorija koja odgovarapaketima kako je to odreeno u izvornom kodu.

Parametar -encoding odreuje kodnu stranicu koju e Java prevodioc koristiti prilikom i-tanja izvornih kodova programa. Ovo je vano zadati ako u izvornom kodu postoje dijakritikiznakovi i slini specifini simboli. Tada je nuno znati koju je kodnu stranicu ureiva tekstakoristio prilikom pohrane izvornog koda programa i tu kodnu stranicu treba ovdje navesti.Kako bi se rijeio taj problem, najjednostavnije je podesiti ureiva teksta tako da izvornekodove uvijek pohranjuje koristei kodnu stranicu UTF-8 i to bez markera BOM.

Parametar -deprecation nalae prevodiocu da prilikom prevoenja izvornog koda dojavisve lokacije na kojima je pronaao uporabu razreda i metoda koje su proglaene napute-nima i koje stoga treba izbjegavati. Razredi i metode koji se u nekoj verziji Jave proglasenaputenima kandidati su za uklanjanje iz buduih verzija Jave i za njih obino postoji doku-mentirana zamjena koju bi trebalo koristiti.

Parametar -g definira da se u izvrni kod pohrane i dodatne informacije koje e kasnije omo-guiti lake debugiranje programa. Tijekom razvoja i ispitivanja programa stoga je uobiajenotraiti da se u izvrni kod ubace informacije poput originalnih naziva lokalnih varijabli, tonogretka u kojem se pojedine naredbe nalaze u izvornom kodu i slino.

Konano, posljednji argument naredbe ine datoteke koje je potrebno prevesti. U naem pri-mjeru trai se prevoenje svih datoteka koje su smjetene u direktoriju src\hr\fer\ze-mris\java\tecaj_1 i koje imaju ekstenziju .java.

Pokretanje izvrnog programa

24

Ako u izvornom programu postoji koja pogreka, to e biti prijavljeno na ekranu. Ako pak ne-ma pogreaka, u direktoriju bin dobit emo izgeneriranu strukturu direktorija koja odgova-ra paketu hr.fer.zemris.java.tecaj_1 i unutra e se nalaziti datototeka HelloWorld.class.Datoteke s ekstenzijom .class sadre izvrni Java kod (odnosno byte-code). Teme-ljem datoteke s izvornim kodom HelloWorld.java nastat e datoteka s izvrnim kodomHelloWorld.class. Po uspjenom prevoenju programa sada emo na disku imati slje-dee direktorije i datoteke.

D:\ +-- javaproj +-- projekt1 +-- src | +-- hr | +-- fer | +-- zemris | +-- java | +-- tecaj_1 | +-- HelloWorld.java +-- bin +-- hr +-- fer +-- zemris +-- java +-- tecaj_1 +-- HelloWorld.class

Pokretanje izvrnog programaJednom kada smo dobili izvrni program, njegovo pokretanje obavlja se pozivom Javinogvirtualnog stoja i predavanjem punog naziva razreda koji radri metodu main. Pod pojmompuni naziv razreda pri tome se podrazumijeva zadavanje paketa u kojem se razred nala-zi kao i lokalnog imena razreda u tom paketu. U naem sluaju, imamo razred ije je imeHelloWorld i koji se nalazi u paketu hr.fer.zemris.java.tecaj_1; njegovo puno ime tada jehr.fer.zemris.java.tecaj_1.HelloWorld, odnosno dobije se tako da se na nazivpaketa nadoda ime razreda.

Javin virtualni stroj poziva se naredbom java. Pokretanje naeg programa obavit emo kakoje prikazano u nastavku.

d:\javaproj\projekt1>java -cp bin \ hr.fer.zemris.java.tecaj_1.HelloWorld

Ako je sve u redu, pokretanjem virtualnog stroja na e se program pokrenuti i na ekran eispisati definiranu poruku. Da bi virtualni stroj znao gdje da trai datoteke s izvrnim progra-mom, koristi se parametar -cp (to je pokrata od classpath) pomou kojeg se zadaju loka-cije unutar kojih virtualni stroj treba traiti izvrne kodove razreda koje izvodi. U odreenomsmislu, to je sinonim varijabli okruenja PATH koja za ljusku navodi direktorije u kojima trebatraiti izvrne verzije programa koje korisnik pokuava pokrenuti navoenjem samo njihovogimena. Kako smo izvorni kod programa smjestili u direktorij bin, tu vrijednost smo specifici-rali kao vrijednost parametra.

Ljuska na Windowsima i problemi s kodnomstranicomKorisnici koji ove primjere izvode kroz ljusku Command Prompt na operacij-skom sustavu Windows mogu se nai u situaciji da je ispis dijakritikih znakova

Sloeniji primjer

25

(i moda nekih drugih simbola) neispravan. Do problema moe doi ako Javinvirtualni stroj prilikom ispisa na konzolu koristi drugaiju kodnu stranicu u odnosuna kodnu stranicu koju koristi sama konzola. U tom sluaju prilikom ispisa dijakri-tikih znakova Javin virtualni stroj generira i konzoli poalje kod koji konzola pro-tumai u skladu s drugom kodnom stranicom kao neki drugi znak. U tom sluajupokrenite naredbu chcp koja e ispisati koju kodnu stranicu koristi konzola (pri-mjerice, ispis bi mogao biti Active code page: 852). Jednom kada ste utvr-dili koju kodnu stranicu koristi konzola, iskoristite parametar -Dfile.encodingkako biste biste Javinom virtualnom stroju zadali kodnu stranicu koju mora ko-ristiti prilikom komuniciranja s okolinom. Primjer je dan u nastavku.

d:\javaproj\projekt1>java -cp bin \ -Dfile.encoding=IBM852 \ hr.fer.zemris.java.tecaj_1.HelloWorld

Sloeniji primjerPogledajmo za vjebu jedan malo sloeniji primjer. Napisat emo program koji e se sastojatiiz dva razreda. Razred Formule sadravat e kod koji e svojim klijentima omoguiti dobi-vanje usluge ispisa neke sluajno odabrane popularne formule iz fizike na ekran. Potom e-mo definirati i jednog klijenta tog razreda, razred Glavni koji e ujedno predstavljati i ulaznutoku u na program. Nakon ispisa pozdravne poruke, glavni e program zatraiti ispis jednesluajno generirane popularne formule iz fizike na zaslon, i potom e zavriti s radom. Izvornikod ovog programa dan je u primjeru 2.2.

Iako je ovo tek drugi program koji razmatramo, moda nije loe osvrnuti se na razlog zbogkojeg su ovdje napravljena ak dva razreda, iako smo sve mogli staviti u isti razred i dapae,sve je moglo biti u istoj metodi (primjerice, u metodi main). Jedna od karakteristika dobrogkoda jest jasnoa koda i modularnost. Kod ne smije biti monolitan a njegovi sastavni dijelovitrebaju biti takvi da neki drugi programer koji ita taj kod moe bez znaajnog truda razumjetito se dogaa u pojedinim dijelovima koda.

Jedna od posljedica prethodnog zahtjeva jest da se programere potie da rjeenja bilo kojegproblema strukturiraju na nain da postoji dio koda koji je konceptualno na vioj razini i kojiproblem rjeava dekompozicijom na podprobleme koji se pak delegiraju drugim dijelovimakoda. to to tono znai, ovisi o paradigmi koju koristimo (proceduralna paradigma, funkcij-ska paradigma, objektno-orijentirana paradigma i slino). Primjerice, u istoj proceduralnojparadigmi to bismo mogli tumaiti kao: neka svaka metoda problem rjeava oslanjajui se nadruge metode koje rjeavaju jednostavnije podprobleme. Dapae, u nedostatku drugaijegnaina grupiranja, tu bismo mogli rei i sljedee: cjelokupni izvorni kod razloit emo u viedatoteka tako da svaka datoteka sadri funkcije i metode koje ine jednu konceptualnu cjeli-nu. U objektno-orijentiranoj paradigmi na raspolaganju imamo i puno ekspresivnija sredstva:program moemo razloiti u pakete, svaki paket moe sadravati razrede i podpakete a svakirazred moe sadravati vie metoda.

U ovom konkretnom primjeru, uoimo da jedan dio programa zahtjeva funkcionalnost kojabi mogla biti bitna i zanimljiva i drugim programima (definiranje poznatih formula fizike i nji-hov ispis na zaslon) to je ve samo po sebi dosta dobar argument da se implementacijate funkcionalnosti izdvoji u zasebnu cjelinu koja nije direktno ovisna o nainu na koji emoje iskoristiti u ovom programu. Stoga je ta funkcionalnost izolirana u zaseban razred For-mule u okviru kojeg je definirana metoda ispisiSlucajnuFormulu koja nudi pristup tojfunkcionalnosti.

Sloeniji primjer

26

Primjer2.2.Sloeniji primjer -- ispis sluajno odabrane formuleNajprije je dan sadraj datoteke Formule.java a potom datoteke Glavni.java.

1 package hr.fer.zemris.java.tecaj_1; 2 3 /** 4 * Razred sadri funkcionalnost ispisa sluajno odabrane 5 * poznate formule iz fizike na zaslon. Program trenutno 6 * raspolae s dvije formule iz podruja relativistike 7 * te Newtonove fizike; autori su, naravno, Einstein i 8 * Newton. 9 * 10 * @author Marko upi 11 * @version 1.0 12 */ 13 public class Formule { 14 15 /** 16 * Metoda posredstvom sluajnog mehanizma prilikom svakog 17 * poziva temeljem uniformne distribucije odabire jednu od 18 * formula s kojima raspolae i ispisuje je na zaslon. 19 * Ispisuje je i popratno zaglavlje. 20 */ 21 public static void ispisiSlucajnuFormulu() { 22 boolean prva = Math.random() < 0.5; 23 System.out.println("Jedna od najpoznatijih formula fizike:"); 24 System.out.println("======================================"); 25 if(prva) { 26 System.out.println(" E = m * c^2"); 27 } else { 28 System.out.println(" F = m * a"); 29 } 30 } 31 32 }

1 package hr.fer.zemris.java.tecaj_1; 2 3 /** 4 * Program koji ilustrira razdvajanje koda u vie razreda. 5 * 6 * @author Marko upi 7 * @version 1.0 8 */ 9 public class Glavni { 10 11 /** 12 * Metoda od koje kree izvoenje programa. 13 * @param args argumenti komandne linije. Ne koristimo ih. 14 */ 15 public static void main(String[] args) { 16 System.out.println(); 17 System.out.println("Pozdrav! Uimo javu!"); 18 System.out.println(); 19 Formule.ispisiSlucajnuFormulu(); 20 } 21 22 }

Pakiranje izvrnogprograma u arhivu

27

Drugi vaan segment ovog programa jest osigurati da se na zaslon najprije ispie pozdrav-na poruka te da se potom ispie jedna sluajno odabrana formula fizike. Ovaj podproblemrijeen je izradom razreda Glavni koji je opremljen metodom main ime moe predstavljatiulaznu toku u program. U okviru te metode dalje je ponuena implementacija koja ispisujepozdravnu poruku te potom koristei uslugu razreda Formule dovrava posao ispisa jednesluajno odabrane formule.

Napravite direktorij za novi projekt (nazovite direktorij projekt2). U tom novom direktori-ju napravite poddirektorije src i bin. U direktoriju src napravite potrebnu strukturu pod-direktorija koja e odgovarati paketu hr.fer.zemris.java.tecaj_1 i unutra stvorite datotekeFormule.java i Glavni.java u skladu s izvornim kodom prikazanim u primjeru 2.2. Timeete dobiti strukturu direktorija koja je prikazana u nastavku.

D:\ +-- javaproj +-- projekt2 +-- src | +-- hr | +-- fer | +-- zemris | +-- java | +-- tecaj_1 | +-- Formule.java | +-- Glavni.java +-- bin

Uz pretpostavku da ste pozicionirani u direktoriju D:\javaproj\projekt2, program eteprevesti i pokrenuti na sljedei nain.

d:\javaproj\projekt2>javac -sourcepath src -d bin -encoding UTF-8 \ -deprecation -g:lines,vars,source \ src\hr\fer\zemris\java\tecaj_1\*.java

d:\javaproj\projekt2>java -cp bin \ hr.fer.zemris.java.tecaj_1.Glavni

Pozdrav! Uimo javu!

Jedna od najpoznatijih formula fizike:====================================== F = m * a

Pakiranje izvrnog programa u arhivuPrilikom prevoenja Java programa za svaku datoteku s izvornim kodom nastat e jedna da-toteka s izvrnim kodom, osim ako se u toj datoteci ne nalazi vie razreda ili pak ugnijeeniili anonimni razredi -- tada e nastati i vie od jedne datoteke s izvrnim kodom. Posljedica jeda Java program nije, u onom klasinom smislu na koji smo navikli, jedna datoteka. To pakponekad moe uiniti distribuciju aplikacija pisanih u Javi problematinom. Kako bismo Javaprogram pretvorili u jednu datoteku, na raspolaganju nam stoji alat jar (en

java cupic

Documents