Skripta - FER

Sveu£ili²te u Zagrebu 

Fakultet elektrotehnike i ra£unarstva 

Marko Topolnik 

Uvod u programski jezik Java 

Skripta uz kolegij Seminar Java+XML 

Zagreb, 2005.

Sadrºaj 

Predgovor 

ix 

Uvod 1 

1 Osnovni elementi jezika Java 3 

1.1 Objektna paradigma, enkapsulacija . . . . . . . . . . . . . . 3 

1.2 Pokretanje programa pisanih u Javi . . . . . . . . . . . . . . 5 

1.2.1 Rad u naredbenom retku . . . . . . . . . . . . . . . . 6 

1.2.2 Rad u okruºju Eclipse . . . . . . . . . . . . . . . . . 6 

1.3 Pojam klase . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

1.4 Povezivanje objekata, izgradnja objektnog sustava . . . . . . 8 

1.5 Inicijalizacija objekta konstruktorom . . . . . . . . . . . . . 9 

1.6 Povezivanje objekata agregacijom . . . . . . . . . . . . . . . 11 

1.7 Polimorzam i Javino su£elje . . . . . . . . . . . . . . . . . . 13 

1.8 Izbjegavanje ponavljanja koda naslježivanjem . . . . . . . . 18 

1.9 Klasna hijerarhija, apstraktna klasa . . . . . . . . . . . . . . 20 

1.10 Paketi, imenovanje klasa i su£elja . . . . . . . . . . . . . . . 23 

1.10.1 Koncepcija paketa . . . . . . . . . . . . . . . . . . . 23 

1.10.2 Pravila imenovanja paketa . . . . . . . . . . . . . . . 24 

1.10.3 Pravila za raspored datoteka po kazalima . . . . . . . 25 

1.10.4 Uloga paketno-privatne razine dostupnosti . . . . . . 25 

1.11 Refaktorizacija . . . . . . . . . . . . . . . . . . . . . . . . . 26 

1.11.1 Modikator final kontrola polimorzma . . . . . . 26 

1.12 Uvoženje vi²e varijanti iste metode preoptere¢enje . . . . . 28 

1.13 Prijelaz s agregacije na kompoziciju kopiranje objekata . . 30 

2 Razrada detalja jezi£nih svojstava 33 

2.1 Varijabla, referenca, objekt . . . . . . . . . . . . . . . . . . . 33 

2.1.1 Varijabla primitivne vrste . . . . . . . . . . . . . . . 33 

i

ii 

SADRšAJ 

2.1.2 Varijabla referentne vrste . . . . . . . . . . . . . . . . 34 

2.1.3 Opseg vidljivosti (scope) lokalne varijable . . . . . . . 35 

2.2 Primitivne vrste podataka . . . . . . . . . . . . . . . . . . . 36 

2.3 Numeri£ki i logi£ki izrazi . . . . . . . . . . . . . . . . . . . . 37 

2.3.1 Numeri£ki operatori . . . . . . . . . . . . . . . . . . 37 

2.3.2 Logi£ki operatori . . . . . . . . . . . . . . . . . . . . 38 

2.3.3 Uvjetni (ternarni) operator . . . . . . . . . . . . . . . 39 

2.3.4 Operatori sloºene dodjele . . . . . . . . . . . . . . . . 39 

2.3.5 Pretvorbe izmežu numeri£kih vrsta . . . . . . . . . . 39 

2.4 Enumeracija . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 

2.5 Konstrukcije za upravljanje slijedom izvr²avanja . . . . . . . 43 

2.6 Sve razine dostupnosti . . . . . . . . . . . . . . . . . . . . . 45 

2.6.1 Model klasne enkapsulacije . . . . . . . . . . . . . . . 46 

2.7 Stati£ka metoda izuzeta od polimorzma . . . . . . . . . . 46 

2.8 Stati£ki atribut, konstanta . . . . . . . . . . . . . . . . . . . 48 

2.8.1 Modikator final rekapitulacija . . . . . . . . . . 49 

2.9 Pravila oblikovanja identikatora . . . . . . . . . . . . . . . 49 

2.10 Upcast i downcast . . . . . . . . . . . . . . . . . . . . . . . . 50 

2.10.1 Operator instanceof . . . . . . . . . . . . . . . . . 51 

2.11 Implicitni parametar metode this . . . . . . . . . . . . . . 52 

2.11.1 Parametar this i polimorzam . . . . . . . . . . . . 53 

2.12 Detalji o hijerarhiji klasa . . . . . . . . . . . . . . . . . . . . 55 

2.12.1 Korijenska klasa Object . . . . . . . . . . . . . . . . 55 

2.12.2 Denicije izraza vezanih uz hijerarhiju . . . . . . . . 55 

2.12.3 Ulan£avanje poziva konstruktora . . . . . . . . . . . 56 

2.13 Java kao softverska platforma . . . . . . . . . . . . . . . . . 57 

3 Najvaºnije ugražene klase 59 

3.1 Uvodne upute za snalaºenje u Javinoj dokumentaciji API-ja 59 

3.2 Klasa java.lang.Object . . . . . . . . . . . . . . . . . . . 62 

3.2.1 Metoda equals . . . . . . . . . . . . . . . . . . . . . 62 

3.2.2 Metoda hashCode . . . . . . . . . . . . . . . . . . . . 64 

3.2.3 Metoda toString . . . . . . . . . . . . . . . . . . . . 66 

3.3 Klasa java.lang.String . . . . . . . . . . . . . . . . . . . 66 

3.3.1 Provjera jednakosti znakovnih nizova . . . . . . . . . 67 

3.3.2 Nepromjenjivost instanci String-a . . . . . . . . . . 68 

3.4 Klasa System . . . . . . . . . . . . . . . . . . . . . . . . . . 69

SADRšAJ 

iii 

3.5 Klase-omota£i primitivnih vrsta, autoboxing . . . . . . . . . 69 

3.6 Konverzija izmežu podatka i njegovog znakovnog zapisa . . . 70 

4 Iznimke 73 

4.1 Bacanje iznimke prijava iznimne situacije . . . . . . . . . . 74 

4.2 Hvatanje iznimke obrada iznimne situacije . . . . . . . . . 76 

4.3 Zavr²ne radnje prije bacanja iznimke blok finally . . . . 78 

4.4 Vi²estruki blokovi catch . . . . . . . . . . . . . . . . . . . . 79 

4.5 Najava iznimke; provjeravana i neprovjeravana iznimka . . . 81 

4.5.1 Najava vi²e iznimki . . . . . . . . . . . . . . . . . . . 82 

4.6 Klasna hijerarhija iznimki . . . . . . . . . . . . . . . . . . . 82 

4.7 Kori²tenje ugraženih i vlastitih iznimki . . . . . . . . . . . . 83 

5 Kolekcije objekata 87 

5.1 Su£elja Collection, List i Set . . . . . . . . . . . . . . . . 87 

5.2 Prelazak preko svih £lanova kolekcije . . . . . . . . . . . . . 90 

5.3 Kolekcije i primitivne vrste podataka . . . . . . . . . . . . . 91 

5.4 Napredni prelazak po £lanovima kolekcije . . . . . . . . . . . 92 

5.5 Mapa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 

5.6 ƒesto kori²teni algoritmi nad kolekcijama . . . . . . . . . . . 94 

5.6.1 Implementiranje su£elja java.lang.Comparable . 94 

5.6.2 Poredak razli£it od prirodnog su£elje 

java.util.Comparator . . . . . . . . . . . . . . 95 

5.6.3 Primjer kori²tenja metode Collections.sort . . . . 96 

6 Polja 99 

6.1 Osnovni elementi sintakse . . . . . . . . . . . . . . . . . . . 99 

6.2 Polje kao objekt . . . . . . . . . . . . . . . . . . . . . . . . . 101 

6.3 Interakcija s kolekcijama . . . . . . . . . . . . . . . . . . . . 101 

7 Komunikacija s okolinom 103 

7.1 Tokovi podataka . . . . . . . . . . . . . . . . . . . . . . . . 103 

7.2 Pisa£i i £ita£i . . . . . . . . . . . . . . . . . . . . . . . . . . 104 

7.3 Komunikacija s korisnikom . . . . . . . . . . . . . . . . . . . 106 

7.4 Rad s datotekama . . . . . . . . . . . . . . . . . . . . . . . . 107 

7.5 Rad s internetskim konekcijama . . . . . . . . . . . . . . . . 107

iv 

SADRšAJ 

8 Uzorci u dizajnu koda 109 

8.1 Template method . . . . . . . . . . . . . . . . . . . . . . . . 109 

8.2 Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 

8.3 Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 

8.4 Decorator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 

9 Savjeti za rad u Eclipse-u 119 

9.1 Automatizacija rada na kodu . . . . . . . . . . . . . . . . . 119 

9.2 Povijest datoteke . . . . . . . . . . . . . . . . . . . . . . . . 120 

9.3 Seljenje projekta s ra£unala na ra£unalo . . . . . . . . . . . 121 

9.3.1 Tipi£an problem prilikom selidbe . . . . . . . . . . . 121 

9.3.2 Savjeti za uspje²nu selidbu . . . . . . . . . . . . . . . 121 

Literatura 123

Popis ispisa 

1.1 Klasa SimpleCounter . . . . . . . . . . . . . . . . . . . . . . . 3 

1.2 Klasa ModuloCounter s druga£ijom metodom increment . . . . 4 

1.3 Izvr²na klasa . . . . . . . . . . . . . . . . . . . . . . . . . . 5 

1.4 Program koji koristi dvije instance iste klase . . . . . . . . . 7 

1.5 Klasa DifferentialCounter . . . . . . . . . . . . . . . . . . . 8 

1.6 Pro²irena varijanta klase SimpleCounter . . . . . . . . . . . . 9 

1.7 Kori²tenje konstruktora . . . . . . . . . . . . . . . . . . . . . 10 

1.8 Analizator teksta . . . . . . . . . . . . . . . . . . . . . . . . 11 

1.9 Analiza vi²edijelnog dokumenta . . . . . . . . . . . . . . . . 12 

1.10 Nadomjesna implementacija klase TextFile . . . . . . . . . . 12 

1.11 Polimorfni analizator teksta . . . . . . . . . . . . . . . . . . 13 

1.12 Su£elje Counter . . . . . . . . . . . . . . . . . . . . . . . . . 14 

1.13 Polimorzam na djelu . . . . . . . . . . . . . . . . . . . . . 14 

1.14 Jo² jedan primjer kori²tenja polimorzma . . . . . . . . . . . 16 

1.15 Obvezivanje na implementaciju su£elja . . . . . . . . . . . . 17 

1.16 Naslježivanje osnovna klasa . . . . . . . . . . . . . . . . . 18 

1.17 Naslježivanje izvedena klasa . . . . . . . . . . . . . . . . . 19 

1.18 Apstraktna klasa . . . . . . . . . . . . . . . . . . . . . . . . 21 

1.19 Konkretne klase izvedene iz apstraktne . . . . . . . . . . . . 22 

1.20 Nova verzija apstraktne klase . . . . . . . . . . . . . . . . . 27 

1.21 Nove konkretne klase . . . . . . . . . . . . . . . . . . . . . . 27 

1.22 Pro²ireno su£elje Counter . . . . . . . . . . . . . . . . . . . . 29 

1.23 Pro²irenje apstraktne klase . . . . . . . . . . . . . . . . . . . 29 

1.24 Dodatak metode za kopiranje u su£elje Counter . . . . . . . . 30 

1.25 Klasa SimpleCounter s dodanom podr²kom za kopiranje . . . 30 

1.26 Analizator teksta koji koristi kompoziciju . . . . . . . . . . . 31 

2.1 Implicitna pretvorba vrste cjelobrojnih podataka . . . . . . . 39 

2.2 Eksplicitna pretvorba vrste cjelobrojnih podataka . . . . . . 40 

v

vi 

POPIS ISPISA 

2.3 Jednostavna enumeracija . . . . . . . . . . . . . . . . . . . . 40 

2.4 Osnovno kori²tenje enumeracije . . . . . . . . . . . . . . . . 41 

2.5 Kori²tenje enumeracije u bloku switch . . . . . . . . . . . . . 41 

2.6 Oboga¢ena enumeracija . . . . . . . . . . . . . . . . . . . . . 42 

2.7 Kratki primjeri uporabe upravlja£kih konstrukcija . . . . . . 43 

2.8 Izjave break i continue koje koriste oznake . . . . . . . . . . . 44 

2.9 Model klasne enkapsulacije . . . . . . . . . . . . . . . . . . . 46 

2.10 Poziv stati£ke metode . . . . . . . . . . . . . . . . . . . . . . 47 

2.11 Poziv stati£ke metode sintaksom kao da je instancina metoda 48 

2.12 Stati£ki atribut, javna konstanta . . . . . . . . . . . . . . . . 48 

2.13 ModuloCounter s dodatnom metodom setModulus . . . . . . . . 50 

2.14 Metoda koja upravlja ModuloCounter-om . . . . . . . . . . . . 51 

2.15 Doražena metoda useCounter . . . . . . . . . . . . . . . . . . 52 

2.16 Implicitni parametar this . . . . . . . . . . . . . . . . . . . 52 

2.17 Neuspio poku²aj uvoženja eksplicitnog parametra this . . . 53 

2.18 Neuspio poku²aj kori²tenja metode s eksplicitnim this . . . . 54 

2.19 Eksplicitan poziv konstruktora natklase . . . . . . . . . . . . 56 

2.20 Poziv konstruktora iste klase . . . . . . . . . . . . . . . . . . 57 

3.1 Implementacija metode equals . . . . . . . . . . . . . . . . . 62 

3.2 Tipi£na pogre²ka s preoptere¢enjem umjesto nadja£avanjem 63 

3.3 Predloºak za generiranje he²-koda . . . . . . . . . . . . . . . 65 

3.4 Implementacija metode toString . . . . . . . . . . . . . . . . 66 

3.5 Posljedice pogre²nog kori²tenja == za usporedbu String-ova . 67 

4.1 ModuloCounter s provjerom parametra . . . . . . . . . . . . . 73 

4.2 Bacanje i ponovno bacanje iznimke . . . . . . . . . . . . . . 75 

4.3 Izvje²taj o ba£enoj iznimci . . . . . . . . . . . . . . . . . . . 75 

4.4 Hvatanje iznimke . . . . . . . . . . . . . . . . . . . . . . . . 76 

4.5 Blok finally . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 

4.6 Vi²estruki blokovi catch . . . . . . . . . . . . . . . . . . . . 79 

4.7 Najava iznimke . . . . . . . . . . . . . . . . . . . . . . . . . 81 

4.8 Deniranje vlastite iznimke . . . . . . . . . . . . . . . . . . 84 

5.1 Osnovno baratanje kolekcijom . . . . . . . . . . . . . . . . . 87 

5.2 Lista i skup . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 

5.3 Prolaz po kolekciji petljom enhanced for . . . . . . . . . . . 90 

5.4 Kolekcija i primitivne vrste podataka . . . . . . . . . . . . . 91 

5.5 Prolaz po kolekciji eksplicitnim kori²tenjem iteratora . . . . 92 

5.6 Kori²tenje iteratora za mijenjanje liste . . . . . . . . . . . . 92

POPIS ISPISA 

vii 

5.7 Klasa Student koja demonstrira mapu . . . . . . . . . . . . . 93 

5.8 Metoda compareTo . . . . . . . . . . . . . . . . . . . . . . . . 95 

5.9 Komparator za studente koji name¢e poredak po ID-ju . . . 95 

6.1 Rad s jednodimenzionalim poljem . . . . . . . . . . . . . . . 99 

6.2 Rad s dvodimenzionalnim poljem . . . . . . . . . . . . . . . 99 

6.3 Prolaz po svim £lanovima polja petljom enhanced for . . . . 100 

6.4 Trokutasto dvodimenzionalno polje . . . . . . . . . . . . . . 100 

6.5 Prolaz po polju kori²tenjem eksplicitnog indeksa . . . . . . . 101 

6.6 Pretvorbe izmežu polja i liste . . . . . . . . . . . . . . . . . 101 

7.1 Rad s izlaznim tokom . . . . . . . . . . . . . . . . . . . . . . 103 

7.2 Rad s ulaznim tokom . . . . . . . . . . . . . . . . . . . . . . 104 

7.3 Pisa£ i £ita£ . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 

7.4 Omota£i podatkovnih tokova . . . . . . . . . . . . . . . . . . 105 

8.5 Su£elje oslu²kiva£a dolaznih paketa . . . . . . . . . . . . . . 111 

8.6 Jednostavna implementacija oslu²kiva£a dolaznih paketa . . 111 

8.7 Komunikacijski £vor s podr²kom za oslu²kiva£e . . . . . . . . 111 

8.8 Kori²tenje sustava . . . . . . . . . . . . . . . . . . . . . . . . 112 

8.9 Pokazna izvedba adaptera na znakovni tok . . . . . . . . . . 113 

8.10 Primjer primjene uzorka Decorator . . . . . . . . . . . . . . 116

Predgovor 

Svrha ovog kolegija (to£nije, njegovog dijela posve¢enog jeziku Java) je 

ne samo uputiti studente u sintaksu jezika Java, ve¢ prije svega podu£iti 

tehnike objektno-orijentiranog programiranja i dizajna sustava objekata. 

Na ovaj predmet uglavnom se dolazi s tek minimalnim predznanjem programiranja 

u imperativnoj paradigmi i bez razvijenih vje²tina u dizajnu 

programskog sustava. To minimalno predznanje naºalost £ak predstavlja i 

smetnju u savladavanju Jave i objektno-orijentiranog pristupa jer daje la- 

ºan dojam poznatosti jezi£nim konstrukcijama koje ustvari imaju druga£ije 

zna£enje i, ²to je jo² vaºnije, druga£iju ulogu u jeziku. 

Pri savladavanju nove, objektne paradigme student kao prvo treba dobro 

razumjeti osnovna svojstva i mogu¢nosti objekta, ali to jo² uvijek nije 

dovoljno za uspje²no rje²avanje zadataka. Jednako je bitno razviti vje²tinu 

organiziranja £itavog sustava objekata koji predstavlja rje²enje zadanog 

problema. Za mnoge elementarne probleme postoje standardna rje²enja 

koja je razvijateljska zajednica prihvatila kao najbolja. Sva takva rje²enja 

treba usvojiti umjesto otkrivati toplu vodu vlastitim pristupima. Po£etnik 

treba biti svjestan da jo² nije do²ao u poziciju da ima puni pregled nad 

razlozima za²to je neko rje²enje bolje od drugog. 1 Takožer, tendencija studenata 

je da se za rje²avanje nekih od problema oslanjaju na ve¢ poznate 

tehnike iz jezika C i imaju velik otpor pri usvajanju tehnika uobi£ajenih za 

Javu. 

U£enje programskog jezika u mnogo£emu podsje¢a na u£enje prirodnog 

jezika. Iz istog razloga za²to nitko jo² nije nau£io npr. engleski jezik isklju- 

£ivo £itaju¢i gramatiku i rje£nik, nitko nije i ne¢e nau£iti Javu isklju£ivo 

£itaju¢i ovu skriptu i slu²aju¢i predavanja. Neizostavna aktivnost jest tre- 

1 Detaljnija argumentacija ovoga krije se iza fraze shu-ha-ri (usvajanje pravilakr²enje 

pravila-napu²tanje pravila) o kojoj se moºe informirati na Webu, npr. 

c2.com/cgi/wiki?ThreeLevelsOfAudience 

ix

x 

Predgovor 

ning, a to u ovom kontekstu zna£i vlastoru£no pisanje koda iz nule, uz stalni 

nadzor asistenta koji zadaje zadatke, prou£ava va²a rje²enja i konstantno 

vas korigira i usmjerava. Dakle, nije ispravno preuzeti zadatak i rje²avati 

ga u izolaciji: kriterij uspjeha nije krajnji proizvod sadrºan u datotekama 

.java, nego vje²tina koju ste stekli. Zadatak je tek sredstvo, primjer na 

kojem se moºe najbolje utvrditi razina va²e vje²tine i, ponajprije, pratiti 

podizanje te razine tijekom semestra. U praksi, studenti koji bez interakcije 

s asistentom na kraju semestra dolaze s rje²enjem zadatka dijele se u dvije 

skupine: oni £iji kod je niske kvalitete i jasno je da nisu ni²ta nau£ili i oni 

£iji kod je kvalitetan jer se nadaju da asistent ne¢e shvatiti da taj kod nije 

njihovo djelo. U drugoj skupini ima dodu²e i ne²to onih koji zaista posjeduju 

potrebne vje²tine, ali tek vrlo malo onih koji su te vje²tine usvojili 

samostalno tijekom semestra. 

Iako nije dovoljna sama za sebe, ova skripta ima vaºnu ulogu u £itavom 

procesu u£enja: da biste uop¢e mogli komunicirati s nekim poznavateljem 

Jave, morate ve¢ razumjeti odreženi skup pojmova i stru£nih izraza. Ako 

asistent kaºe npr. ovaj atribut ne bi trebao biti stati£ki jer mu je vrijednost 

razli£ita za svaku instancu, onaj tko nije ni pro£itao skriptu ne¢e imati 

koristi od takvog savjeta jer ga naprosto ne¢e razumjeti. Jednako tako, 

prilikom ispitivanja dogodit ¢e vam se da ne razumijete postavljeno pitanje, 

iako biste moºda £ak i znali odgovor. 

Na kraju, ºelim se izjasniti i po pitanju jedne vrlo pro²irene predrasude: 

pisanje dobrog koda nije nikakvo mehanizirano ²trikanje, to je intelektualno 

zahtjevan i kreativan proces sa svojom vlastitom estetikom. Ako netko 

smatra druga£ije, to je najvjerojatnije stoga ²to nije jo² razvio estetske kriterije 

da bi uvidio razliku izmežu lijepog, kreativnog i ruºnog, nabacanog 

koda. Ta £injenica predstavlja zna£ajnu prepreku: u£enik prvo treba skupiti 

motivaciju da umo£i noge da bi uop¢e do²ao u poziciju da cijeni vlastiti 

rad, a tko ne cijeni ono ²to radi ne moºe ni imati dobro mi²ljenje o svojoj 

struci. 

dr.sc. Marko Topolnik 

Zagreb, 1. rujna 2005.

Uvod 

Nastava na kolegiju Seminar Java+XML sastoji se iz dva dijela: predavanja 

i laboratorijske vjeºbe, s time da je teºi²te na vjeºbama. Organizacija 

samih vjeºbi na kolegiju je speci£na. Glavnina termina (oko pet-²est) posve¢ena 

je izradi malog softverskog projekta. Termine vjeºbi treba prije 

svega koristiti za komunikaciju s asistentom koji ¢e nadzirati va² napredak 

na projektu. Ovaj moment je kriti£an jer se va²a ocjena prvenstveno formira 

upravo tijekom te komunikacije, a na kraju semestra bit ¢e posebno 

ispitivani samo oni studenti koji iz bilo kojeg razloga nisu suraživali s asistentom 

tijekom semestra. Kriterij za ocjenu nije ispravan rad aplikacije koju 

ste razvili, ve¢ razina vje²tine programiranja koju ste stekli. Izradi projekta 

prethode manji zadaci na kojima ¢ete savladati najosnovnije tehnike rada 

s razvojnim alatom i pisanja samog koda. Rje²enja zadataka ocjenjuju se 

neovisno o projektu. 

Skripta se odnosi na Javinu verziju 5 (Java 2 Platform Standard Edition 

5.0). Sadrºaj ove skripte bit ¢e izlagan na predavanjima, tako da se 

studentima preporu£a da unaprijed pro£itaju poglavlje £ija ¢e se materija 

izlagati na sljede¢em predavanju. 

U skripti je obražen samo osnovni podskup jezika Java. Neka od izostavljenih 

podru£ja: 

• ugnjeºžene klase nose zna£ajan dio ukupne kompleksnosti jezika i 

intenzivno se koriste u programiranju GUI-ja; 

• reeksija sluºi za zaobilaºenje ograni£enja Javinog stati£kog odreživanja 

vrste izraza; 

• model vi²enitnosti omogu¢uje kori²tenje vi²e izvr²nih niti (dretvi) i 

sinkroniziran pristup zajedni£kim resursima. Bit ¢e pokriven u predmetu 

Konkurentno programiranje. 

1

2 Uvod 

Takožer je iznimno vaºno imati na umu da je i materija koja se obražuje 

u skripti obražena samo sa svrhom uvoda u Javu za po£etnika nikako se ne 

smije shvatiti kao potpuna informacija. Gotovo sve ovdje re£eno predstavlja 

drasti£no pojednostavljenje u odnosu na preciznu i potpunu istinu, sve u 

svrhu lak²e razumljivosti po£etniku. Ako je £itatelj ve¢ poznavatelj Jave i 

takva ga pojednostavljenja smetaju, neka slobodno odloºi skriptu jer njemu 

ona i ne treba. 

Studentu se preporu£a da prvo poglavlje pro£ita u cijelosti jer se tamo 

spominje velik broj najvaºnijih pojmova, a tekst je pisan kao jedna pri£a 

u kojoj se pojmovi uvode gdje koji zatreba. Tekst daljnjih poglavlja nije 

toliko usko povezan pa £itanje po redu nije tako bitno.

Poglavlje 1 

Osnovni elementi jezika Java 

1.1 Objektna paradigma, enkapsulacija 

U objektno-orijentiranom programskom jeziku izrada programa moºe se u 

osnovi svesti na izgradnju sustava objekata. Objekti su mežusobno povezani 

(znaju jedan za drugog) i mežusobno komuniciraju razmjenom poruka, 

²to se svodi na to da jedan objekt poziva metode drugoga. Dakle, pri kretanju 

u rje²avanje zadanog problema prvo treba osmisliti koji objekti ¢e biti 

potrebni i kako ¢e biti povezani. ƒesto je mogu¢e posti¢i da programski 

objekti modeliraju stvarne objekte. Za svaki objekt najvaºnije je utvrditi 

²to ¢e se od njega o£ekivati da radi, tj. njegovo pona²anje. U praksi to se 

svodi na popis metoda koje ¢e on posjedovati. Za svaku metodu najbitnije 

je koje argumente prima i kakvu vrijednost vra¢a. Takožer je bitno na koji 

na£in poziv metode utje£e na stanje objekta. O stanju ovisi kako ¢e objekt 

odgovarati na budu¢e pozive metoda. Dakle, identi£an poziv metode u razli£itim 

trenucima moºe vratiti razli£itu vrijednost, ovisno o stanju u kojem 

je objekt zate£en. Stanje objekta u praksi se svodi na vrijednosti njegovih 

atributa (unutarnjih varijabli, na engleskom se u kontekstu Jave £esto 

koristi i izraz eld). Osnovno na£elo dizajna objekata enkapsulacija ili 

zatvaranje nalaºe da stanje objekta mora ostati skriveno, a izvana trebaju 

biti vidljive samo one posljedice tog stanja koje su zaista potrebne dakle 

utjecaj stanja na povratne vrijednosti metoda. Evo jednostavnog primjera 

opisa objekta u Javi: 

public class SimpleCounter 

Ispis 1.1: Klasa SimpleCounter 

3

4 POGLAVLJE 1. OSNOVNI ELEMENTI JEZIKA JAVA 

{ 

private int counterState; 

} 

public void increment() 

{ 

this.counterState++; 

} 

public int getState() 

{ 

return this.counterState; 

} 

Na² objekt opisan klasom SimpleCounter raspolaºe dvjema metodama, 

od kojih jedna mijenja njegovo stanje (increment), a druga to stanje dojavljuje 

vanjskom svijetu (getState). Dakle, rezultat metode getState je ovisan 

o trenutnom stanju objekta. Stanje je pohranjeno u atributu counterState. 

To je obi£an cijeli broj (vrste int, poznat iz jezika C). Pri kreiranju objekta 

svi brojevni atributi se implicitno inicijaliziraju na vrijednost nula. 

UML-ov dijagram klase SimpleCounter prikazan je na slici 1.1. 

SimpleCounter 

-counterState : int 

+increment() 

+getState() : int 

Slika 1.1: UML-ov dijagram klase SimpleCounter 

Vaºno je da svi atributi imaju oznaku private, £ime se ostvaruje na£elo 

skrivenosti stanja odnosno enkapsulacije. U protivnom bi ih objektu iza 

leža mogli mijenjati drugi objekti. Recimo da imamo malo druga£iju klasu, 

ModuloCounter, £ija metoda increment ustvari izgleda ovako: 

Ispis 1.2: Klasa ModuloCounter s druga£ijom metodom increment 

public class ModuloCounter 

{ 


{ 

if ( this.counterState == 9 ) 

this.counterState = 0; 

else 


}

POGLAVLJE 1. OSNOVNI ELEMENTI JEZIKA JAVA 5 

} 

... atribut counterState i metoda getState isti kao u SimpleCounter ... 

dakle, da broja£ cirkularno broji samo do devet i onda se vra¢a na nulu. Kad 

atribut counterState ne bi bio privatan, mogao bi se izvana promijeniti na 

proizvoljnu vrijednost, npr. 10. Time bi se naru²ila funkcionalnost objekta 

jer bi se, kao prvo, broja£ na²ao u nedozvoljenom stanju i, kao drugo, daljnji 

pozivi metode increment nastavili bi brojati prema beskona£nosti. 

Enkapsulacija, iako ju sam jezik Java ne name¢e, uglavnom je neizostavan 

dio dizajna objekta jer spre£ava velik broj programerskih pogre²aka uz 

naj£e²¢e malu ili nikakvu ºrtvu u eleganciji koda. Takožer daje programeru 

ve¢u slobodu u eventualnom redizajniranju objekta. Imena i podatkovne 

vrste (tipovi) atributa mogu se proizvoljno mijenjati dok god se zadrºava 

isto pona²anje objekta kakvo se o£ituje u vrijednostima koje vra¢aju metode. 

1.2 Pokretanje programa pisanih u Javi 

U jeziku Java program se pokre¢e tako da se prvo denira izvr²nu klasu 

koja sadrºi posebnu metodu main. Ona ¢e biti implicitno pozvana kad izvr- 

²imo klasu, tj. pokrenemo svoj program. Metoda prima parametar polje 

znakovnih nizova. U njemu su pobrojani argumenti zadani u naredbenom 

retku prilikom pokretanja programa. 

Ispis 1.3: Izvr²na klasa 

public class AppThatUsesTheCounter 

{ 

public static void main( String[] args ) 

{ 

SimpleCounter cntr = new SimpleCounter(); 

System.out.println( "Po£etno stanje broja£a: " + cntr.getState() ); 

cntr.increment(); 

System.out.println( "Stanje nakon poziva metode increment: " 

+ cntr.getState() ); 

} 

} 

Prikazana metoda main stvara jedan objekt, koristi ga i o rezultatima 

izvje²¢uje korisnika ispisom teksta na zaslon. Izraz new SimpleCounter() kreira 

novi objekt klase SimpleCounter. Referenca na taj objekt zapisuje se u


lokalnu varijablu cntr i nakon toga se preko te varijable mogu pozivati 

metode objekta. Ispis koji generira program bi trebao biti sljede¢i: 

Po£etno stanje broja£a: 0 

Stanje nakon poziva metode increment: 1 

1.2.1 Rad u naredbenom retku 

Nekim editorom teksta treba stvoriti datoteku s izvornim kodom. Ime datoteke 

mora biti identi£no imenu klase + suks .java. Datoteku se prevodi 

(kompajlira) Javinim alatom javac (Java compiler): 

$ javac AppThatUsesTheCounter.java 

Rezultat ovog koraka nije izvr²na datoteka koju se moºe izravno pokrenuti. 

Rezultat je klasna datoteka (eng. class le) koja sadrºi binarnu 

deniciju klase u posebnom Javinom mežukodu (eng. bytecode, vidjeti odjeljak 

2.13). To je izvr²ni kod za tzv. Javin virtualni stroj (eng. Java Virtual 

Machine odnosno JVM) posebnu hardversku platformu koja postoji samo 

na papiru, a svaka realna hardverska platforma ju emulira. Dakle, u naredbenom 

retku treba pokrenuti emulator, tj. JVM, i proslijediti mu ime 

na²e izvr²ne klase: 

$ java AppThatUsesTheCounter 

Vaºno! Kao argument ove naredbe ne navodi se ime klasne datoteke, ve¢ 

samo ime klase. To ¢e pogotovo biti vaºno kasnije, kad uvedemo pakete 

(odjeljak 1.10). 

1.2.2 Rad u okruºju Eclipse 

Kako pokrenuti ovaj primjer u Eclipse-u (vrijedi za verziju 3.1): 

1. File, New, Project... Java Project, Next 

2. Upisati ime projekta, uvjeriti se da je uklju£eno Create separate source 

and output folders, Finish 

3. U okviru Package Explorer na¢i projekt, ekspandirati ga, namjestiti 

oznaku na direktorij src.


4. File, New, Class. Upisati ime klase. U editorskom okviru otvara se 

stvorena datoteka i u njoj ve¢ pi²e prvi redak koda. Upisati ostatak 

koda. 

5. Pokretanje klase: desni klik na izvr²nu klasu u Package Explorer-u, 

Run As, Java Application. Ili, dok je kurzor u editoru doti£ne klase, 

upotrijebiti kombinaciju tipaka Alt-Shift-X, J. 

6. U okviru Console vidi se ispis programa. 

7. Ako bilo koji od okvira nije vidljiv, moºe ga se otvoriti pomo¢u Window, 

Show view 

1.3 Pojam klase 

U ovom trenutku moºe se usvojiti i osnovna ideja klase. Moºemo ju smatrati 

predlo²kom za objekte koji prvenstveno propisuje koje atribute ¢e objekt 

imati za £uvanje stanja i sadrºi denicije metoda koje ¢e se nad njim mo¢i 

pozivati. Objekt se jo² naziva i instancom svoje klase. Sve instance iste klase 

imaju isti popis atributa, ali naravno svaka ima svoje vlastite vrijednosti 

tih atributa. To se moºe ilustrirati ako izmijenimo tekst gornje metode main 

na sljede¢i: 

Ispis 1.4: Program koji koristi dvije instance iste klase 


{ 

SimpleCounter cntr1 = new SimpleCounter(); 


System.out.println( "Po£etna stanja broja£a: " + cntr1.getState() + 

", " + cntr2.getState() ); 

cntr1.increment(); 

System.out.println( "Stanja nakon poziva metode increment nad cntr1: " 

+ cntr1.getState() + ", " + cntr2.getState() ); 

} 

O£ekivani ispis: 

Po£etna stanja broja£a: 0, 0 

Stanja nakon poziva metode increment nad cntr1: 1, 0 

Klasa AppThatUsesTheCounter s ispisa 1.3 je druga£ija: ona ne opisuje 

nikakav smisleni objekt, ve¢ samo sadrºi metodu main koja je poseban slu£aj 

i nije normalna metoda objekta. O tome ¢e se vi²e raspravljati kasnije (u 

odjeljku 2.7).


1.4 Povezivanje objekata, izgradnja objektnog 

sustava 

Dva objekta moºe se povezati tako da jedan objekt sadrºi atribut koji 

pokazuje na drugi objekt, npr. 

Ispis 1.5: Klasa DifferentialCounter 

public class DifferentialCounter 

{ 

private SimpleCounter cntr1 = new SimpleCounter(); 

private SimpleCounter cntr2 = new SimpleCounter(); 

} 

public void increment1() 

{ 

this.cntr1.increment(); 

} 

public void increment2() 

{ 

this.cntr2.increment(); 

} 

public int getDifference() 

{ 

return this.cntr2.getState() - this.cntr1.getState(); 

} 

public void reset() 

{ 

this.cntr1 = new SimpleCounter(); 

this.cntr2 = new SimpleCounter(); 

} 

UML-ovi klasni i objektni dijagram za ovaj slu£aj prikazani su na slikama 

1.2 i 1.3. 

cntr1 

diffCounter1 

cntr2 

Slika 1.2: Objektni dijagram minimalnog objektnog sustava


DifferentialCounter 

+increment1() 

+increment2() 


-cntr1, cntr2 

1 2 

SimpleCounter 


+increment() 


Slika 1.3: Klasni dijagram minimalnog objektnog sustava 

Objekt klase DifferentialCounter povezan je s dva objekta klase Simple- 

Counter i komunicira s njima. Na primjer, kad se pozove metoda getDifference, 

objekt ¢e stupiti u kontakt sa svakim od broja£a i zatraºiti njihovo trenutno 

stanje. Time je izgražen minimalan sustav objekata. Asocijativni odnos izmežu 

DifferentialCounter i SimpleCounter naziva se kompozicijom. Klju£na 

karakteristika ovog odnosa je da podreženi objekti postoje isklju£ivo kao 

sastavni dio nadreženog i njihovo postojanje je uvjetovano tim objektom. U 

to se moºemo uvjeriti ako uvidimo da je DifferentialCounter taj koji stvara 

podrežene objekte i da nijedan vanjski objekt ne moºe do¢i do reference 

na njih (zapisane su u privatnim atributima, nijedna javna metoda ih ne 

vra¢a). 

Prikazani slu£aj u kojem se atributi cntr1 i cntr2 inicijaliziraju na mjestu 

gdje su i deklarirani samo je jedan od na£ina inicijalizacije atributa. Na 

primjer, metoda reset takožer ih (re)inicijalizira, stvaraju¢i nove objekte 

SimpleCounter (time se stari objekti implicitno odbacuju i bit ¢e automatski 

uklonjeni iz radne memorije postupkom zvanim garbage collection, sakupljanje 

sme¢a). Tipi£an na£in inicijalizacije atributa je unutar konstruktora, 

o kojem ¢e se pri£ati u sljede¢em odjeljku. 

1.5 Inicijalizacija objekta konstruktorom 

Svaki put kad upotrijebimo klju£nu rije£ new kojom zatraºimo kreiranje 

nove instance zadane klase, implicitno smo zatraºili i pozivanje posebne 

inicijalizacijske procedure opisane konstruktorom objekta. Svaka klasa ima 

bar jedan konstruktor, a ako ih ima vi²e, oni se razlikuju po broju i vrstama 

parametara. Pomo¢u parametara moºemo prenijeti dodatnu informaciju 

inicijalizacijskom postupku, £ime postiºemo da se objekt inicijalizira 

u onakvo stanje kakvo je potrebno u danom trenutku. Primjerice, moºemo 

pro²iriti na²u klasu SimpleCounter:


Ispis 1.6: Pro²irena varijanta klase SimpleCounter 


{ 


public SimpleCounter( int initialState ) 

{ 

this.counterState = initialState; 

} 

public SimpleCounter() 

{ 

//ne radi ni²ta dodatno; counterState se automatski 

//inicijalizira na nulu 

} 

} 

... deklaracije metoda increment i getState kao ranije ... 

U kodu 1.6 denirana su dva konstruktora: prvi prima jedan cijeli broj 

po£etnu vrijednost broja£a. Drugi je takozvani podrazumijevani konstruktor 

onaj koji ne prima nijedan parametar. U ranijem slu£aju (ispis 1.1), 

iako nije bio deklariran nijedan, klasi je implicitno dodan upravo ovakav, 

prazan podrazumijevani konstruktor. Mežutim, £im deklariramo bilo koji 

konstruktor eksplicitno, ni²ta se ne dodaje implicitno. Dakle, klasa ne mora 

imati podrazumijevani konstruktor, iako bi se to moglo zaklju£iti sude¢i po 

njegovom imenu. 

Primjer poziva konstruktora: 

Ispis 1.7: Kori²tenje konstruktora 


{ 


SimpleCounter cntr2 = new SimpleCounter( 3 ); 

System.out.println( "Po£etna stanja broja£a: " + cntr1.getState() + 

", " + cntr2.getState() ); 


System.out.println( "Stanja nakon poziva metode increment nad cntr1: " 

+ cntr1.getState() + ", " + cntr2.getState() ); 

} 

U ovom primjeru cntr1 se inicijalizira podrazumijevanim konstruktorom, 

a cntr2 konstruktorom koji putem parametra zaprima ºeljeno po£etno 

stanje. O£ekivani ispis: 

Po£etno stanje broja£a: 0, 3 

Stanje nakon poziva metode increment nad cntr1: 1, 3


1.6 Povezivanje objekata agregacijom 

Uzmimo da imamo objekt koji sluºi za jednostavnu analizu tekstualne 

datoteke ustanovljuje koliko redaka teksta sadrºi. Datoteku predstavlja 

objekt vrste TextFile. Nad njim moºemo pozvati metodu readLine koja 

£ita jedan redak datoteke i metodu endReached koja nas izvje²tava ima li jo² 

redaka za pro£itati. Za £uvanje rezultata brojanja koristi se objekt vrste 

SimpleCounter. Objekt-analizator teksta je instanca klase TextAnalyzer: 

public class TextAnalyzer 

{ 

private SimpleCounter cntr; 

private TextFile file; 

private boolean countDone; 

} 

Ispis 1.8: Analizator teksta 

public TextAnalyzer( SimpleCounter cntr, TextFile file ) 

{ 

this.cntr = cntr; 

this.file = file; 

} 

public int countLines() 

{ 

if ( !this.countDone ) 

{ 

while ( !file.endReached() ) 

{ 

file.readLine(); 

this.cntr.increment(); 

} 

this.countDone = true; 

} 

return cntr.getState(); 

} 

Najvaºnije je uo£iti da konstruktor klase prima kao parametre instance 

klasa SimpleCounter i TextFile. Moºemo u zapisu konstruktora vidjeti da 

se reference na te objekte izravno prepisuju u atribute cntr odnosno file. 

Klasa TextAnalyzer stoga ima asocijativnu vezu prema SimpleCounter-u i 

TextFile-u, ali ovdje se ne radi o kompoziciji, koju smo sreli ranije. To 

se vidi po tome ²to TextAnalyzer prima izvana stvorene objekte, tako da 

oni nisu njegovi privatni. Ovdje to moºe biti sasvim korisno: recimo da 

imamo jedan ve¢i dokument razbijen u vi²e datoteka, npr. jedna datoteka


za svako poglavlje. Ono ²to nas zanima je ukupan broj redaka u £itavom 

dokumentu. To moºemo posti¢i kori²tenjem na²eg analizatora teksta ovako 

(primjer pretpostavlja da imamo dokument razbijen u dvije datoteke): 

Ispis 1.9: Analiza vi²edijelnog dokumenta 


{ 

TextFile file1 = new TextFile( 15 ); // datoteka od 15 redaka 

TextFile file2 = new TextFile( 25 ); // datoteka od 25 redaka 

SimpleCounter cntr = new SimpleCounter(); 

} 

TextAnalyzer ta1 = new TextAnalyzer( cntr, file1 ); 

System.out.println( 

"Broj redaka u prvoj datoteci: " + ta1.countLines() ); 

// Instanciramo analizator druge datoteke, ali s istim broja£em: 

TextAnalyzer ta2 = new TextAnalyzer( cntr, file2 ); 

System.out.println( "Ukupan broj redaka: " + ta2.countLines() ); 


Broj redaka u prvoj datoteci: 15 

Ukupan broj redaka: 40 

Iz primjera je jasno da je ºivotni vijek objekta broja£a neovisan o 

objektu analizatora. Objekt analizatora, nakon ²to je obavio svoj posao, 

moºe se ukloniti iz memorije a da to ne utje£e na objekt broja£a. Za takav 

slu£aj koristi se izraz agregacija to je op¢enito odnos izmežu cjeline i njenih 

sastavnih dijelova, bez obzira na to pripadaju li dijelovi isklju£ivo toj 

cjelini ili ne. Uo£imo da kompozicija takožer zadovoljava ovu deniciju, ali 

je njena denicija stroºa. Dakle, svaka kompozicija je ujedno i agregacija, 

ali obrat ne vrijedi. UML-om se agregacija prikazuje kao na slici 1.4. 

TextFile 1 1 

TextAnalyzer 

-cntr 

SimpleCounter 

+countLines() : int 

-file 


1 

1 

+increment() 


Slika 1.4: UML-ov dijagram klasa u odnosu agregacije 

U kodu klase TextAnalyzer koristi se objekt vrste TextFile. Umjesto punog 

objekta koji radi s pravim datotekama radi isprobavanja koristimo ovaj 

jednostavan nadomjestak:


Ispis 1.10: Nadomjesna implementacija klase TextFile 

public class TextFile 

{ 

private int linesTotal; 

private int linesRead; 

} 

public TextFile( int lineCount ) 

{ 

this.linesTotal = lineCount; 

} 

public void readLine() 

{ 

if ( this.linesRead < this.linesTotal ) 

this.linesRead++; 

} 

public boolean endReached() 

{ 

return this.linesRead == this.linesTotal; 

} 

1.7 Polimorzam i Javino su£elje 

U Javi moºemo razdvojeno opisati su£elje objekta prema okolini (dakle 

popis metoda s kojima raspolaºe) i implementaciju tog su£elja (sam kod 

metoda, atributi potrebni za £uvanje stanja). Posebno je bitno da za jednu 

deniciju su£elja moºemo imati mnogo razli£itih implementacija. Ovo je 

korisno iz mnogo razloga, a ovdje ¢emo opisati jedan od njih. 

Recimo da imamo gornji slu£aj analizatora teksta. šelimo da, ovisno o 

konkretnoj primjeni, moºemo dobiti ili ukupan broj redaka ili samo njegovu 

posljednju znamenku (brojanje modulo 10, kao u ispisu 1.2). Treba uvesti 

samo sitnu izmjenu u kod s ispisa 1.8: 


{ 

private Counter cntr; 


private boolean countDone; 

Ispis 1.11: Polimorfni analizator teksta 

public TextAnalyzer( Counter cntr, TextFile file ) 

{ 

this.cntr = cntr;


} 

this.file = file; 

} 


{ 

if ( !this.countDone ) 

{ 


{ 



} 

this.countDone = true; 

} 


} 

Ovaj kod je identi£an kao ranije, osim ²to se umjesto SimpleCounter 

koristi vrsta Counter, £iju deniciju jo² nismo vidjeli. Radi se o Javinom 

su£elju: 

public interface Counter 

{ 

void increment(); 

int getState(); 

} 

Ispis 1.12: Su£elje Counter 

U su£elju, kao ²to smo najavili, nema denicije metoda, ve¢ samo popis 

metoda koje objekt s tim su£eljem posjeduje, tj. deklaracije metoda. Konstruktor 

klase TextAnalyzer prihvatit ¢e bilo koji objekt koji implementira 

to su£elje, a metodi countLines bit ¢e svejedno o kakvoj se to£no implementaciji 

radi. Mežutim, razli£ite implementacije rezultirat ¢e razli£itim 

pona²anjem metode. Ova karakteristika objektno-orijentiranih jezika zove 

se polimorzam ili vi²eobli£nost. Metoda misli da uvijek radi s objektom 

iste vrste (Counter), koji se iz te perspektive doima kao da se mijenja od 

slu£aja do slu£aja jednom se moºe pona²ati kao SimpleCounter, a drugi 

put kao ModuloCounter. Uo£imo i jo² jednu sitnicu: metode u su£elju nisu 

ozna£ene kao public jer se to podrazumijeva nemogu¢e je u su£elju imati 

metodu koja ne bi bila javna. Klasu TextAnalyzer moºemo koristiti npr. 

ovako: 

Ispis 1.13: Polimorzam na djelu



{ 

TextAnalyzer ta1 = 

new TextAnalyzer( new SimpleCounter(), new TextFile( 37 ) ); 

TextAnalyzer ta2 = 

new TextAnalyzer( new ModuloCounter(), new TextFile( 37 ) ); 

} 

int count1 = ta1.countLines(); 

int count2 = ta2.countLines(); 

System.out.println( "SimpleCounter je izbrojao " + count1 ); 

System.out.println( "ModuloCounter je izbrojao " + count2 ); 


SimpleCounter je izbrojao 37 

ModuloCounter je izbrojao 7 

Prisutnost polimorzma moºemo uo£iti ve¢ u prvom retku koda. Konstruktoru 

klase TextAnalyzer, koji je deniran da prima argumente vrste 

Counter, proslježuje se referenca na instancu klase SimpleCounter. Jezi£na 

pravila to dopu²taju jer objekt SimpleCounter implementira su£elje Counter 

(uz sitan dodatak, prikazan u ispisu 1.15) i nad njim je mogu¢e pozvati sve 

metode deklarirane u su£elju. U drugom retku istom konstruktoru proslježuje 

se referenca na instancu druge klase ovaj put ModuloCounter. U tre¢em 

i £etvrtom retku najjasnije se vidi djelovanje polimorzma. Nad ta1 i ta2 

poziva se ista metoda s identi£nim argumentom. Time se pokre¢e identi£an 

kod metode countLines (ispis 1.11). Mežutim, ta dva poziva rezultiraju razli£itim 

povratnim vrijednostima, ²to se manifestira u ispisu u posljednja dva 

retka. Razlika nastupa u trenutku izvr²avanja retka this.cntr.increment(), 

gdje se donosi odluka koju to£no metodu increment() treba pozvati. U prvom 

slu£aju to ¢e biti metoda denirana u klasi SimpleCounter, a u drugom 

slu£aju u ModuloCounter. Dakle, taj redak propisuje samo ime metode koju 

¢e se pozvati (i parametre koje ona mora imati), ali ne veºe se ni uz jednu 

konkretnu metodu. Ovaj postupak zove se dinami£ko povezivanje za razliku 

od stati£kog, gdje se u trenutku prevoženja (kompajliranja) donosi 

kona£na odluka o tome koja metoda ¢e biti pozvana. 

Novu situaciju sa su£eljem moºemo vizualizirati UML-ovim dijagramom 

sa slike 1.5. Ovakav stil dizajna, u usporedbi s dizajnom sa slike 1.4, od 

presudne je vaºnosti u objektno-orijentiranim jezicima. Gotovo bi se moglo 

re¢i da je £injenica da omogu¢uju takav dizajn smisao njihovog postojanja.


Uz malu izmjenu na ispisu 1.13 moºemo pokazati jo² jedan tipi£an na£in 

kori²tenja polimorzma: 

Ispis 1.14: Jo² jedan primjer kori²tenja polimorzma 


{ 

Counter cntr1 = new SimpleCounter(); 

Counter cntr2 = new ModuloCounter(); 

TextAnalyzer ta1 = new TextAnalyzer( cntr1 ); 

TextAnalyzer ta2 = new TextAnalyzer( cntr2 ); 

} 

... ostatak identi£an kao gore ... 

Ovdje se u prva dva retka varijablama vrste Counter pridjeljuju reference 

na instance klasa SimpleCounter odnosno ModuloCounter. Zatim se s tim varijablama 

poziva konstruktor klase TextAnalyzer. Ovaj uzorak, gdje se za 

vrstu varijable koristi su£elje umjesto konkretne klase, vrlo je uobi£ajen u 

praksi. Isto vrijedi i za vrste atributa. Su£elje se redovito koristi i, kao ²to 

smo vidjeli u primjeru, za vrste parametara a takožer i za vrste povratnih 

vrijednosti metoda. Na£elno, uvijek treba koristiti najop¢enitiju vrsta koja 

dolazi u obzir a to je u na²im primjerima su£elje Counter. 

TextAnalyzer 


1 

-cntr 

«interface» 

Counter 

1 +increment() 


SimpleCounter 

ModuloCounter 

+increment() 


+increment() 


Slika 1.5: UML-ov dijagram klasa za polimorfni analizator teksta (klasa 

TextFile je ovdje izostavljena) 

U Javi svaka klasa mora se unaprijed obvezati koja sve su£elja (moºe ih 

biti vi²e) ¢e implementirati. U na²em slu£aju bit ¢e potrebno dodati redak 

implements Counter u deklaracije obiju klasa. Puni kod tako izmijenjenih


klasa prikazan je na ispisu 1.15. Primijetimo i mali dodatak u konstruktoru 

klase ModuloCounter kojim se osigurava od slu£aja zadavanja prevelikog 

po£etnog broja uzimanjem ostatka dijeljenja s 10. 

Ispis 1.15: Obvezivanje na implementaciju su£elja 


implements Counter 

{ 


} 


{ 


} 


{ 

} 


{ 


} 


{ 


} 



{ 


public ModuloCounter( int initialState ) 

{ 

this.counterState = initialState % 10; 

} 

public ModuloCounter() 

{ 

} 


{ 



else 

this.counterState++;


} 

} 


{ 


} 

1.8 Izbjegavanje ponavljanja koda naslježivanjem 

Ono ²to nas u ispisu 1.15 moºe zasmetati, a u kompleksnijem kodu moºe 

prerasti i u puno ve¢i problem, je ponavljanje koda u dvije o£ito srodne 

klase. Obje klase koriste isti atribut, a i metoda getState im je identi£na. 

Java omogu¢uje tehniku kojom se takvo ponavljanje moºe izbje¢i naslježivanje 

(eng. inheritance). U na²em slu£aju mogli bismo postupiti tako 

da propi²emo da klasa ModuloCounter ne nastaje od nule, ve¢ da je izvedena 

(eng. derived) iz klase SimpleCounter. U tom slu£aju ona ¢e naslijediti 

sve njene metode i atribute. Nakon toga moºemo predenirati (nadja£ati, 

eng. override) one metode £ija implementacija vi²e ne odgovara (metodu 

increment). Izvodom se izmežu ModuloCounter i SimpleCounter uspostavlja 

odnos potklasa-natklasa. 

Konstruktori se ne naslježuju i moramo ih uvijek pisati iznova. Mežutim, 

u prvom retku konstruktora moºemo pozvati odgovaraju¢i konstruktor 

iz natklase i time prepustiti njemu odraživanje zajedni£kog dijela posla. 



{ 

int counterState; 

Ispis 1.16: Naslježivanje osnovna klasa 


{ 


} 


{ 

} 


{


} 


} 


{ 


} 

Ispis 1.17: Naslježivanje izvedena klasa 


extends SimpleCounter 

{ 


{ 

super( initialState % 10 ); 

} 

} 


{ 

} 

@Override 


{ 

super.increment(); 



} 

U ovom slu£aju bili smo prisiljeni pro²iriti dostupnost atributu counter- 

State uklanjanjem modikatora private. Time je njegova dostupnost pro²irena 

na paketno-privatnu (eng. package-private) razinu: dostupan je iz svih 

klasa unutar istog paketa (o tome kasnije, u odjeljku 1.10), pa tako i iz 

potklase ModuloCounter. Prou£imo novu implementaciju metode increment 

u potklasi. Implementacija je izvedena tako da se prvo pozove izvorna implementacija 

iz natklase (super.increment), a zatim se korigira slu£aj kad 

broja£ dože do 10 i treba ga poni²titi. Ova tehnika je vrlo prikladna u u£estaloj 

situaciji iz prakse gdje je posao koji obavlja izvorna metoda ve¢inom 

ispravan, ali ga treba jo² malo korigirati ili pro²iriti. Op¢enito, nadja£avaju¢a 

metoda nema obvezu pozivati metodu iz natklase, a ako ju poziva, 

nije nuºno da to £ini u prvom retku koda. Poziv pomo¢u super koristi se i 

u zapisu konstruktora vi²e o ovome u odjeljku 2.12.3.


Iznad denicije metode increment u ModuloCounter-u pojavljuje se i @Override. 

To je tzv. Javin annotation, primjedba uz metodu. Postoje razne vrste 

annotation-a, a ovdje kori²ten Override nazna£uje da ta metoda nadja£ava 

metodu iz natklase. Njegovo kori²tenje je opcionalno, ali korisno. Time prevoditelju 

dajemo do znanja da predvižamo da ta metoda nadja£ava metodu 

iz natklase pa ¢e nas on upozoriti ako pogrije²imo i npr. navedemo krivo 

ime metode, recimo inkrement. Takve pogre²ke ponekad je te²ko uo£iti jer 

¢emo time umjesto nadja£avanja denirati novu metodu a da toga nismo 

svjesni. 

Uo£imo jo² i sljede¢e: klasa ModuloCounter ne ponavlja izjavu implements 

Counter jer se to podrazumijeva potklasa automatski, samom prirodom 

naslježivanja, implementira sva su£elja koja implementira njena natklasa. 

1.9 Klasna hijerarhija, apstraktna klasa 

«interface» 

Counter 

+increment() 


SimpleCounter 


+increment() 


ModuloCounter 

+increment() 

Slika 1.6: UML-ov dijagram klasa iz ispisa 1.16 

UML-ov dijagram slu£aja iz ispisa 1.16 prikazan je na slici 1.6. Ova organizacija 

je rije²ila problem ponavljanja koda. Mežutim, sad se pojavio novi 

problem. Dosad je bilo nagla²eno da polimorzam omogu¢uje instancama 

razli£itih klasa da se pona²aju kao da su instance su£elja koje implementiraju. 

Isto se odnosi i na slu£aj instance izvedene klase ona se moºe koristiti 

i kao instanca svoje natklase. U ovom slu£aju to zna£i da sve instance klase


ModuloCounter moºemo tretirati kao da je njihova vrsta SimpleCounter. Ako 

npr. negdje imamo deklariranu metodu 

void setSimpleCounter( SimpleCounter cntr ) 

ona ¢e uredno prihvatiti i argument vrste ModuloCounter. Mežutim, najvjerojatnije 

je da metoda o£ekuje objekt s pona²anjem deniranim u Simple- 

Counter i ne¢e ispravno raditi s druga£ijim objektima. U protivnom je mogla 

npr. zahtijevati argument op¢enite vrste Counter. Ovu situaciju moºemo izbje¢i 

uz uporabu vi²e koda, ali jo² uvijek zadrºavaju¢i tu prednost da se ne 

ponavlja deklaracija atributa ni implementacija metode getState. Moºemo 

u hijerarhiju ubaciti apstraktnu klasu: 

abstract class AbstractCounter 


{ 


Ispis 1.18: Apstraktna klasa 

public AbstractCounter( int initialState ) 

{ 


} 

public AbstractCounter() 

{ 

} 


{ 


} 

} 

public abstract void increment(); 

Glavna novost ovdje je metoda increment, koja je sad postala apstraktna. 

Najavljeno je njeno postojanje, ali nema implementacije. Logi£no slijedi da 

se ovakvu klasu ne smije mo¢i instancirati jer je opis njenog pona²anja 

nepotpun ne zna se ²to bi se trebalo dogoditi prilikom poziva metode 

increment. Upravo tu zabranu uvodi modikator abstract nad klasom. Op- 

¢enito, svaku klasu smije se proglasiti apstraktnom i time zabraniti njeno 

instanciranje bez obzira ima li ona apstraktnih metoda ili ne. S druge 

strane, postojanje ijedne apstraktne metode prisiljava nas da takvu klasu 

proglasimo apstraktnom.


Koji je smisao ovog zahvata? Pogledajmo preureženi kod dviju otprije 

poznatih klasa: 

Ispis 1.19: Konkretne klase izvedene iz apstraktne 


extends AbstractCounter 

{ 


{ 

super( initialState ); 

} 

} 


{ 

} 

@Override 


{ 


} 



{ 


{ 

super( initialState % 10 ); 

} 

} 


{ 

} 

@Override 


{ 



else 


} 

Ovu situaciju prikazuje UML-ov dijagram na slici 1.7. Sad su obje konkretne 

klase izvedene iz AbstractCounter. Sav zajedni£ki kod nalazi se u apstraktnoj 

klasi, a metoda increment implementirana je u svakoj konkretnoj 

klasi posebno. Takva situacija bolje odgovara ulozi jedne i druge klase, koje


su po svojoj prirodi dvije paralelne implementacije su£elja Counter. Uo£imo 

jo² na ispisu 1.18 da je za klasu AbstractCounter izostavljen modikator 

public. Ona ima pomo¢ni karakter i ne bi trebala sluºiti da se deklariraju 

varijable ili parametri £ija vrsta je AbstractCounter. Umjesto toga treba 

uvijek koristiti su£elje Counter. Stoga je njena vidljivost smanjena na samo 

unutar svog paketa. 

«interface» 

Counter 

+increment() 


AbstractCounter 


+increment() 


SimpleCounter 

ModuloCounter 

+increment() 

+increment() 

Slika 1.7: UML-ov dijagram klasa iz ispisa 1.18 i 1.19 

1.10 Paketi, imenovanje klasa i su£elja 

1.10.1 Koncepcija paketa 

Dosad se ve¢ vi²e puta spominjala koncepcija paketa. Vrijeme je da se 

razjasni taj pojam, a i da ga se stavi u potpunu uporabu u kodu. Jezik Java 

omogu¢ava grupiranje vi²e klasa u jednu cjelinu koja se naziva paketom. 

Pripadnost klase paketu objavljuje se u prvom retku datoteke u kojoj je 

denirana, npr. ovako: 

package hr.fer.tel.jsem; 


{ 



}


Time se su£elje Counter na²lo u paketu hr.fer.tel.jsem i sada je njegovo 

puno ime hr.fer.tel.jsem.Counter. U kodu svih klasa unutar tog istog 

paketa ne mora se navoditi puno ime, ali u bilo kojem drugom paketu to 

postaje potrebno. Da kod ipak ne bi postao previ²e zagu²en ovako duga£kim 

imenima, Java podrºava i uvoz pojedinih imena klasa/su£elja tako da 

se na njih moºe pozivati samo kratkim imenom. Za to sluºi klju£na rije£ 

import koja se pojavljuje odmah ispod deklaracije paketa: 


import java.util.List; 

import java.util.ArrayList; 

import javax.swing.*; 

public class Xyz 

{ 

... 

} 

Kori²enjem zvjezdice, kao u javax.swing.*, uvozi se kompletan paket. 

Postoji i poseban paket java.lang koji je automatski uvezen, kao da je uvijek 

navedeno import java.lang.*. U njemu su najvaºnije ugražene klase kao 

²to su String i Object. 

1.10.2 Pravila imenovanja paketa 

U praksi se paketi redovito koriste, tako da sav na² dosada²nji kod u tom 

smislu odudara od prakse i svaku datoteku treba dopuniti tom deklaracijom. 

Ve¢ je vjerojatno o£ito da su na snazi i posebna pravila imenovanja 

paketa: on se imenuje prema imenu internetske domene organizacije pod 

£ijom kapom se izražuje kod, i to tako da se kre¢e od segmenta najvi²e 

hijerarhijske razine. Na² Zavod ima domenu tel.fer.hr i stoga sva imena 

paketa izraženih na Zavodu trebaju po£injati na hr.fer.tel. Za sasvim 

male projekte bit ¢e dovoljan jedan paket, ali ve¢ za samo malo ve¢e trebat 

¢e ih obi£no vi²e. U tom slu£aju opet ¢emo imati glavno ime, kao u na²em 

primjeru hr.fer.tel.jsem, na koje ¢e se dodavati jo² segmenata po potrebi. 

Paketi se primjenjuju prije svega zato da ne dože do sudara izmežu 

imena klasa koje kreiraju razli£iti autori i imaju razli£ite namjene. Upravo 

zato su denirana gornja pravila imenovanja paketa koja osiguravaju jedinstvenost 

njegovog imena. Iz istog razloga treba dobro paziti koja imena


se uvoze da se ne bi uvezlo pogre²no. Na primjer, u standardnu biblioteku 

klasa koja dolazi s Javom ugraženi su i java.awt.List i java.util.List, dvije 

klase vrlo razli£itih namjena. Uvozom pogre²nog imena do¢i ¢e do vrlo £udnih 

pogre²aka gdje se prevoditelj (kompajler) buni za svaku metodu koju 

pozivamo, iako sve izgleda ispravno. 

1.10.3 Pravila za raspored datoteka po kazalima 

Ime paketa u kojem je klasa povla£i za sobom i propis u kojem kazalu 

ona mora biti smje²tena u sustavu datoteka. Po£ev²i od nekog proizvoljnog 

kazala koje se progla²ava korijenskim potrebno je izgraditi hijerarhiju 

kazala identi£nu hijerarhiji segmenata u imenu paketa. Konkretno, datoteka 

Counter.java mora se na¢i u kazalu /hr/fer/tel/jsem. Ime 

same datoteke takožer je propisano i mora biti jednako imenu klase deklarirane 

u njoj. Bez obzira na ovakav hijerarhijski na£in organiziranja paketa 

po kazalima, formalno izmežu dva paketa razli£itog imena ne postoji nikakva 

povezanost. Dakle, paket hr.fer nije u ni²ta bliºem odnosu s paketom 

hr.fer.tel nego s npr. paketom com.sun. 

Svaki razvojni alat automatski se brine za po²tivanje svih ovih pravila 

i stoga je bitno koristiti tu njegovu podr²ku. Na primjer, u ovom trenutku 

trebalo bi sve datoteke, koje su dosad bile u neimenovanom, tzv. podrazumijevanom 

ili korijenskom paketu, preseliti u paket hr.fer.tel.jsem. Jedan 

zgodan na£in u okruºju Eclipse je da se u Package Explorer-u ozna£i sve 

klase i pritisne kombinacija tipaka Alt-Shift-V, £ime se zahtijeva preseljenje 

klasa u drugi paket. Doti£ni jo² ne postoji pa ga se u prozoru koji se 

pojavio stvori pomo¢u gumba New. 

1.10.4 Uloga paketno-privatne razine dostupnosti 

Sad se moºe bolje razumjeti ono ²to se ranije govorilo o razini dostupnosti 

atributa, metoda i klasa. Svaki razvojni projekt u Javi oslanja se na velik 

broj klasa i su£elja koja ve¢ postoje mnogo njih dolazi ve¢ kao dio samog 

jezika, odnosno dostupan je odmah nakon instaliranja Jave na ra£unalo. 

Ve¢ina samih softverskih proizvoda takožer su takve prirode da trebaju 

sluºiti drugim razvijateljima kao gradivni elementi. Korisniku svih tih paketa 

ne¢e biti dostupni oni dijelovi koji nisu ozna£eni kao javni (public). 

Time razvijatelj paketa moºe imati bolju kontrolu nad time kako ¢e se


njegov kod koristiti: olak²ava korisniku ispravno kori²tenje, a i zadrºava 

slobodu kasnijih izmjena nad svim dijelovima koji nisu javni. Na primjer, 

uklanjanje oznake public s klase AbstractCounter sprije£it ¢e korisnka na²eg 

paketa da radi izravno s tom klasom. Kasnije ju moºemo npr. preimenovati 

ili moºda potpuno ukinuti bez utjecaja na korisnika na²eg paketa. 

1.11 Refaktorizacija 

Kako smo napredovali u izgradnji koda na²eg primjera, u vi²e navrata radili 

smo prepravke u kodu s ciljem njegove bolje organizacije (npr. izbjegavanje 

ponavljanja), a bez utjecaja na pona²anje objekata. Takve izmjene u£estale 

su u razvoju softvera i nazivaju se refaktorizacijom. Gledaju¢i trenutno 

stanje na²eg koda (ispisi 1.18 i 1.19), opet moºemo uo£iti jednu sitnicu 

koja bi se mogla popraviti. Klasa ModuloCounter na dva neovisna mjesta 

name¢e ciklus brojanja od nula do devet: posebno u konstruktoru i u metodi 

increment. Takva situacija otvara mogu¢nost za nekonzistentnost moºe se 

gre²kom dogoditi da se na jednom mjestu name¢e npr. ciklus od nula do 7, 

a na drugom do 9. Poºeljno je provesti jo² jednu refaktorizaciju koja ¢e ovo 

otkloniti. Vi²e je na£ina za to, ali ovdje ¢emo pokazati jedan koji sadrºi i 

neke novosti u dizajnu objekata. 

Dosad smo se susreli s enkapsulacijom atributa kao jednom od najosnovnijih 

tehnika dizajna. Mežutim, £esto je korisno enkapsulirati i metode. To 

¢emo ovdje iskoristiti: uvest ¢emo novu, paketno-privatnu metodu setState 

koja ¢e se pozivati prilikom svake promjene stanja i u kojoj ¢e se provoditi 

kontrola nailaska na gornju granicu ciklusa. Dakle, svaka od dviju na²ih 

konkretnih klasa imat ¢e svoju implementaciju setState, a time ¢e nestati 

potreba da metoda increment ima razli£ite implementacije ona ¢e se oslanjati 

na promjenjivo pona²anje metode setState. Za takvu metodu kaºe 

se da je polimorfna. Konstruktor ¢e takožer pozivati ovu metodu. Metoda 

setState nije dio javnog su£elja objekta i stoga se denicija Counter-a ne 

mijenja. Iz perspektive koda koji barata objektima vrste Counter nije se 

dogodila nikakva promjena. 

1.11.1 Modikator final kontrola polimorzma 

U novi kod apstraktne klase dodan je jo² jedan detalj: modikatorom final 

ozna£ene su metode koje je zabranjeno nadja£avati. Uvijek je dobro svaku


metodu za koju je predviženo da bude ista za sve potklase ozna£iti kao 

final. Polimorzam, osim ²to daje eksibilnost, moºe i oteºati £itanje koda 

upravo zbog toga ²to pravila odabira metode koja ¢e biti pozvana postaju 

znatno sloºenija. Oznaka final na metodi garantira da nije potrebno 

pregledavati sve potklase da se ustanovi nije li neka od njih nadja£ala tu 

metodu. To je prakti£nije i za programera koji dodaje novu potklasu jer 

taj modikator isti£e ulogu metode u £itavoj organizaciji klasa i ukazuje 

na to kako ispravno uvesti novu klasu. 




{ 


Ispis 1.20: Nova verzija apstraktne klase 


{ 

setState( initialState ); 

} 


{ 

} 

public final int getState() 

{ 


} 

public final void increment() 

{ 

setState( getState() + 1 ); 

} 

} 

abstract void setState( int newState ); 

U ispisima koji slijede modikatorom final ozna£ene su klase. Kad djeluje 

na klasu, ovaj modikator zabranjuje deklaraciju klase izvedene iz nje. 

Time se ponovo osigurava od polimorzma tamo gdje je on nepoºeljan 

ako npr. parametar neke metode ima vrstu SimpleCounter, garantirano je 

da ¢e prosliježeni objekt biti instanca upravo te klase, a ne neke potklase s 

izmijenjenim pona²anjem. Takav nepoºeljan slu£aj upravo smo imali ranije, 

prije uvoženja apstraktne klase.



Ispis 1.21: Nove konkretne klase 

public final class SimpleCounter 


{ 


{ 


} 

} 


{ 

} 

@Override 

void setState( int newState ) 

{ 

this.counterState = newState; 

} 


public final class ModuloCounter 


{ 


{ 


} 

} 


{ 

} 

@Override 


{ 

this.counterState = newState % 10; 

} 

1.12 Uvoženje vi²e varijanti iste metode preoptere¢enje 

Ovisno o tome za ²to nam sve treba broja£, mogao bi se pojaviti npr. 

zahtjev da treba omogu¢iti i ve¢e korake brojanja umjesto samo po jedan.


U tom slu£aju mogli bismo poja£ati na²e objekte novom varijantom metode 

increment koja prima i jedan brojevni parametar. Tada ¢emo imati dvije 

metode istog imena, ali razli£itih parametara to se zove preoptere¢enjem 

metode (eng. overloading). ’to se ti£e jezika Java, te dvije metode jednako 

su razli£ite kao da imaju i razli£ita imena jer se potpuni identitet metode 

sastoji od njenog imena i popisa vrsta parametara koje prima. Ta cjelina 

naziva se potpisom metode (eng. signature). Konkretno, ovdje ¢emo imati 

metode increment() i increment( int ). Uo£imo da s druge strane povratna 

vrijednost ne ulazi u potpis metode i ne smije se denirati dvije metode 

koje su iste po svemu osim po povratnoj vrijednosti. 


{ 


void increment( int step ); 


} 


Ispis 1.22: Pro²ireno su£elje Counter 

Ispis 1.23: Pro²irenje apstraktne klase 



{ 

.. po£etak koda identi£an kao ranije ... 

} 


{ 

increment( 1 ); 

} 

public final void increment( int step ) 

{ 

setState( getState() + step ); 

} 


Moºemo uo£iti tipi£an pristup koji se koristi u izgradnji sustava preoptere¢enih 

metoda: metoda koja prima cijeli broj je op¢enitija, a metoda 

bez parametara je u biti njen poseban slu£aj u kojem se podrazumijeva jedini£ni 

korak. Stoga se poziv metode bez parametara delegira na op¢enitiju 

metodu, koju se poziva s podrazumijevanom vrijednosti.


Primjer kori²tenja preoptere¢enih metoda: 


{ 

Counter cntr = new SimpleCounter(); 


System.out.println( "Stanje nakon poziva increment(): " 


cntr.increment( 2 ); 

System.out.println( "Stanje nakon poziva metode increment( 2 ): " 


} 

1.13 Prijelaz s agregacije na kompoziciju kopiranje 

objekata 

U ispisu 1.11 denirana je klasa koja primjenjuje agregaciju, ²to je ilustrirano 

slikom 1.4. Konstruktor klase TextAnalyzer zaprima gotovu instancu 

broja£a i ugražuje ju u svoju instancu. U ve¢ini situacija iz prakse ovdje 

¢e ustvari isto biti potrebna prava kompozicija da bi se analizator teksta 

za²titio od neºeljenih intervencija izvana. Ako ºelimo imati oba svojstva 

i da se objekt dobiva izvana, i da se primjenjuje £ista kompozicija bit 

¢e potrebno omogu¢iti kopiranje objekata. Analizator teksta zaprimit ¢e 

objekt izvana i od njega napraviti obrambenu kopiju (eng. defensive copy) 

identi£an objekt, ali privatan. Daljnje promjene nad objektom dobivenim 

izvana ne¢e utjecati na njegov rad. U Javi postoji poseban mehanizam za 

ovo metoda clone mežutim, on se zbog odreženih tehni£kih problema 

po£eo izbjegavati. Ovdje ¢emo stoga prikazati preporu£enu alternativu 

kopiraju¢i konstruktor (eng. copy constructor) u kombinaciji s posebnom 

metodom getCopy. Su£elje broja£a moramo pro²iriti ovom metodom: 

Ispis 1.24: Dodatak metode za kopiranje u su£elje Counter 


{ 


void increment( int step ); 


Counter getCopy(); 

} 

Implementacije ove metode koristit ¢e kopiraju¢e konstruktore. Ovdje se 

donosi primjer za SimpleCounter; za ModuloCounter postupa se analogno.


Ispis 1.25: Klasa SimpleCounter s dodanom podr²kom za kopiranje 




{ 


{ 


} 

} 


{ 

} 

// Kopiraju¢i konstruktor -- broja£ se postavlja na 

// istu vrijednost kao u izvorniku. 

// Privatan! Sluºi samo kao podr²ka metodi getCopy 

private SimpleCounter( SimpleCounter cntr ) 

{ 

this.counterState = cntr.counterState; 

} 

public Counter getCopy() 

{ 

return new SimpleCounter( this ); 

} 


{ 

this.counterState = newState; 

} 

Metodu getCopy, naºalost, ne moºemo rije²iti op¢enito i staviti u apstraktnu 

klasu jer u svakoj klasi treba stvarati instancu upravo te klase. 

Klasu TextAnalyzer jednostavno je prepraviti da koristi mehanizam kopiranja. 

Potrebna je samo sitna izmjena u konstruktoru 1 : 

Ispis 1.26: Analizator teksta koji koristi kompoziciju 


{ 


private Counter cntr; 

public TextAnalyzer( TextFile file, Counter cntr ) 

1 U konstruktoru se koristi i metoda getCopy iz klase TextFile. Njena implementacija 

nije prikazana u skripti.


} 

{ 

} 

this.file = file.getCopy(); 

this.cntr = cntr.getCopy(); 


{ 


{ 



} 


}

Poglavlje 2 

Razrada detalja jezi£nih 

svojstava 

2.1 Varijabla, referenca, objekt 

Jedan od najbitnijih elemenata potrebnih za precizno razumijevanje jezi£nih 

konstrukcija u Javi jest pojam varijable. Ono ²to ¢e ovdje biti re£eno 

za varijablu vrijedi i za parametre metode, uhva¢ene iznimke i atribute 

objekta. Jedna od razlika izmežu lokalne varijable i atributa koju treba 

imati na umu je da se atribut inicijalizira automatski, a lokalna varijabla 

ne. Prevoditelj (kompajler) ¢e analizirati izvorni kod i prijaviti pogre²ku 

ako kod omogu¢ava £itanje varijable prije inicijalizacije. 

Varijabla je spremnik u radnoj memoriji kojem je dodijeljeno ime (identikator) 

i vrsta podatka koji se u nju sprema. Jezik Java razlikuje varijable 

primitivne i referentne vrste. 

2.1.1 Varijabla primitivne vrste 

Varijabla primitivne vrste je jednostavniji od dva slu£aja i poznat je iz jezika 

C. Vrijednost takve varijable je podatak primitivne vrste, npr. boolean, 

int ili double. Sam podatak je izravno spremljen u varijablu i vrijednost varijable 

moºe se izmijeniti jednostavnom dodjelom: 

int i; //deklaracija varijable 

i = 2; //prva dodjela vrijednosti (inicijalizacija) 

i = 3; //druga dodjela vrijednosti ... 

Atributi primitivne vrste inicijaliziraju se na vrijednost nula odnosno, za 

logi£ku vrstu, na false. Varijable se usporežuju po vrijednosti na uobi£ajen 

33

34 POGLAVLJE 2. RAZRADA DETALJA JEZIƒNIH SVOJSTAVA 

na£in: 

int i = 0; 

int j = 0; 

if ( i == j ) 

System.out.println( "Varijable imaju istu vrijednost" ); 

else 

System.out.println( "Varijable imaju razli£ite vrijednosti" ); 

(ispisat ¢e se "Varijable imaju istu vrijednost"). Ako varijablu proslijedimo 

kao argument metodi, metoda ¢e dobiti vlastitu kopiju vrijednosti varijable, 

tako da promjene na toj kopiji ne utje£u na original: 

private static void useInt( int i ) 

{ 

i++; 

} 


{ 

int i = 0; 

useInt( i ); 

System.out.println( i ); // ispisuje "0" 

} 

2.1.2 Varijabla referentne vrste 

U varijablu referentne vrste sprema se referenca na objekt. Vrijednost varijable 

nikad nije sam objekt, ve¢ uvijek referenca na njega. To je vaºno 

imati na umu, pogotovo u sljede¢im situacijama: 

• Dvije varijable mogu imati referencu na isti objekt. Manipulacija 

objektom putem jedne varijable manifestirat ¢e se i kad se objektu 

pristupa putem druge varijable: 


Counter cntr2 = cntr1; 

System.out.println( cntr1.getState() ); // ispisuje "0" 



• Ako se metodi proslježuje objekt putem parametra referentne vrste, 

akcije nad objektom obavljene unutar metode ostat ¢e vidljive na 

objektu i nakon ²to metoda zavr²i:

POGLAVLJE 2. RAZRADA DETALJA JEZIƒNIH SVOJSTAVA 35 

private static void useCntr( Counter cntr ) 

{ 


} 


{ 



useCntr( cntr1 ); 


} 

• Vrijednost dviju varijabli je jednaka samo ako sadrºe istu referencu, tj. 

pokazuju na jedan te isti objekt. Ako pokazuju svaka na svoj objekt, 

njihove vrijednosti ne¢e biti jednake bez obzira na to jesu li sami 

objekti mežusobno jednaki: 


{ 



if ( cntr1 == cntr2 ) 

System.out.println( "Varijable imaju istu vrijednost" ); 

else 

System.out.println( "Varijable imaju razli£ite vrijednosti" ); 

} 

(ispisat ¢e se Varijable imaju razli£ite vrijednosti). Za usporedbu 

samih objekata mora se koristiti posebnu metodu equals (odjeljak 

3.2.1). 

Varijabla referentne vrste moºe imati i posebnu vrijednost null, ²to 

zna£i da ne sadrºi nikakvu referencu. Atributi referentne vrste se automatski 

inicijaliziraju na ovu vrijednost. 

2.1.3 Opseg vidljivosti (scope) lokalne varijable 

Lokalna varijabla uobi£ajeno se deklarira unutar glavnog bloka metode. 

Mežutim, op¢enito njena vidljivost proteºe se uvijek od mjesta deklaracije 

do kraja bloka u kojem je deklarirana: 

public static void method() 

{ 

int i = 0;


} 

if ( i >= 0 ) 

{ 

int j = i + 1; 

} 

j++; // prevoditelj prijavljuje pogre²ku da nije deklarirana 

Nijedna deklaracija lokalne varijable ne smije prekriti drugu lokalnu 

varijablu koja je na tom mjestu vidljiva: 


{ 

int i = 0; 

if ( i >= 0 ) 

{ 

int i = 3; // prevoditelj se tuºi da je varijabla 'i' ve¢ deklarirana 

} 

} 

Sintaksa petlje for omogu¢uje da se ve¢ prije otvorene vitice deklarira 

varijabla koja ¢e vrijediti unutar bloka petlje: 


{ 

for ( int i = 0; i < 33; i++ ) 

{ 

System.out.println( i % 7 ); 

} 

i++; // prevoditelj prijavljuje pogre²ku da nije deklarirana 

} 

2.2 Primitivne vrste podataka 

Jezik Java raspolaºe ograni£enim skupom primitivnih vrsta podataka. Ne 

raspolaºe npr. brojevima bez predznaka. Denirane su sljede¢e vrste: 

• boolean: logi£ka vrijednost, poprima jednu od dvije konstante: true ili 

false. 

• byte: 8-bitni cijeli broj (zapisan u jednom oktetu). 

• short: 16-bitni cijeli broj. 

• char: 16-bitni Unicode-ov znak. Moºe se tretirati i kao broj. Podrºane 

su doslovne vrijednosti, npr. 'a', '\n' za znak prelaska u novi redak, 

'\t' za znak tabulatora.


• int: 32-bitni cijeli broj, koristi se za sve cijele brojeve op¢e namjene, 

kad nema posebno jakih razloga za kori²tenje nekog drugog. 

• long: 64-bitni cijeli broj. 

• float: 32-bitni broj s plivaju¢im zarezom. Preciznost je oko 6 decimalnih 

mjesta. 

• double: 64-bitni broj s plivaju¢im zarezom. Preciznost je oko 15 decimalnih 

mjesta. Najbolje je rutinski koristiti double za decimalne 

brojeve. 

2.3 Numeri£ki i logi£ki izrazi 

Jezik Java raspolaºe uobi£ajenim skupom unarnih i binarnih numeri£kih i 

logi£kih operatora. Ovdje se donosi njihov kratak pregled. 

2.3.1 Numeri£ki operatori 

Unarni operatori: 

• negacija broja, npr -i 

• komplement broja bit-po-bit, npr. £i 

• pre-increment, npr. ++i 

• pre-decrement, npr. --i 

• post-increment, npr. i++ 

• post-decrement, npr. i-- 

Binarni operatori: 

• zbroj, npr. i + j; isti znak koristi se i za operator ulan£avanja (vidjeti 

3.3) 

• razlika, npr. i - j 

• umnoºak, npr. i * j


• koli£nik, npr. i / j. Ako su i i j cijeli brojevi, rezultat ¢e biti cijeli 

broj puta koliko j stane u i. Drugim rije£ima, rezultat se zaokruºuje 

prema nuli odnosno na manju apsolutnu vrijednost. 

• ostatak dijeljenja, npr. i % j. Pravilo za rezultat operacije: (i/j)*j + 

(i%j) = i 

Binarni operatori koji djeluju na razini bitova: 

• pomak (shift) ulijevo, npr. i > j. Na ispraºnjena lijeva 

mjesta stavlja se vrijednost koju je imao najljeviji bit prije operacije. 

Koristi se kad se nad cijelim brojem, bio pozitivan ili negativan, ºeli 

posti¢i efekt dijeljenja s 2 j . 

• pomak udesno uz zero-extension, npr. i >>> j. Na ispraºnjena lijeva 

mjesta stavljaju se nule. Za negativne brojeve naru²ava efekt dijeljenja 

potencijom broja dva. 

• operacija i, npr. i & j 

• operacija ili, npr. i | j 

• operacija isklju£ivo ili, npr. i ¢ j 

Za usporedbu brojeva koriste se operatori == (jednakost), != (nejednakost), 


• isklju£ivo ili, npr. a ¢ b 

• uvjetno i, npr. a && b. Izraz b ¢e se izra£unavati jedino ako je izraz a 

bio istinit. 

• uvjetno ili, npr. a || b. Izraz b ¢e se izra£unavati jedino ako je izraz 

a bio laºan. 

Osim za posebne namjene treba uvijek koristiti uvjetne verzije operatora 

jer je to ra£unski ekonomi£nije. Jedino u slu£aju kad je nuºno da oba 

izraza uvijek budu izra£unata (zbog nekih dodatnih posljedica koje ti izrazi 

ostavljaju) treba koristiti bezuvjetne operatore. 

2.3.3 Uvjetni (ternarni) operator 

Ovaj operator sluºi za odabir izmežu dva izraza od kojih ¢e jedan biti 

rezultat £itave operacije ovisno o zadanom uvjetu. Tipi£an primjer uporabe: 

public static void showErrorMessage( String msg ) 

{ 

String fullMsg = "Error: " + ( msg != null? msg : "" ); 

System.out.println( fullMsg ); 

} 

Ternarni operator koristi se u izrazu msg != null? msg : "". Prvo se provjerava 

uvjet msg != null. Ako je uvjet zadovoljen, rezultat £itavog izraza 

je msg, a u protivnom je rezultat prazan niz, "". 

Ovaj operator nije primjereno koristiti kao op¢enitu zamjenu za 

konstrukciju if-then-else, ve¢ samo u slu£ajevima kao gore, gdje se radi o 

sasvim kratkim izrazima i gdje se time postiºe bolja £itljivost koda. 

2.3.4 Operatori sloºene dodjele 

Za sve binarne operatore za koje je to smisleno postoje i odgovaraju¢i operatori 

sloºene dodjele, npr. i += 3 postoje¢oj vrijednosti varijable i dodaje 

3, a &= b varijabli a pridjeljuje rezultat operacije a & b, itd. 

2.3.5 Pretvorbe izmežu numeri£kih vrsta 

Ako se u numeri£kom izrazu koriste podaci razli£itih vrsta npr. int i 

long, svi podaci niºe preciznosti bit ¢e implicitno pretvoreni u podatke vi²e 

preciznosti. Razmotrimo ovaj primjer kori²tenja cijelih brojeva:


Ispis 2.1: Implicitna pretvorba vrste cjelobrojnih podataka 

int int1 = 1; 

long long1 = 1; 

long long2 = int1; 

long2 = int1 + long1; 

int int2 = long1; // pogre²ka! 

int2 = int1 + long1; // pogre²ka! 

U tre¢em i £etvrtom retku vrijednost vrste int se pridjeljuje varijabli vrste 

long i to je ispravno. Mežutim, u petom i ²estom retku poku²ava se vrijednost 

vrste long pridijeliti varijabli vrste int. Ovdje prevoditelj prijavljuje 

pogre²ku Type mismatch: cannot convert from long to int. 

Java op¢enito po²tuje sljede¢e pravilo: ako zatreba pretvorba na ve¢u 

preciznost, odvija se automatski; ako zatreba pretvorba na manju preciznost, 

potrebno je ekplicitno zatraºiti konverziju. Pogre²ke iz gornjeg primjera 

ispravit ¢emo ovako: 

Ispis 2.2: Eksplicitna pretvorba vrste cjelobrojnih podataka 

int int2 = (int) long1; 

int2 = (int) ( int1 + long1 ); 

Sad prevoditelj ne¢e prijaviti pogre²ku, ali naravno treba imati na umu 

opasnost od prekora£enja maksimalnog opsega int-a. Sve ovdje re£eno vrijedi 

i za odnose izmežu float i double, kao i izmežu float i double s jedne 

strane i cjelobrojnih vrsta s druge strane. 

2.4 Enumeracija 

U softverskom razvoju vrlo £est slu£aj je da neki podatak moºe poprimiti 

svega nekoliko razli£itih vrijednosti. Na primjer, ako razvijamo neku karta²ku 

igru, trebat ¢e podatak s £etiri mogu¢e vrijednosti (pik, karo, herc, 

tref ). Za takve slu£ajeve treba denirati posebnu klasu, tzv. enumeraciju. 

Najosnovniji slu£aj je vrlo jednostavan: 


public enum Suit 

Ispis 2.3: Jednostavna enumeracija


{ 

} 

clubs, diamonds, hearts, spades; 

Enumeracija je ustvari obi£na klasa s javnim konstantama (vidjeti odjeljak 

2.8) £ija vrsta je upravo ta klasa. To moºemo vidjeti na sljede¢em 

primjeru kori²tenja enumeracije: 

Ispis 2.4: Osnovno kori²tenje enumeracije 


{ 

Suit suit1, suit2; 

suit1 = Suit.clubs; 

suit2 = Suit.hearts; 

System.out.println( "Prva boja: " + suit1 + "; druga boja: " + suit2 ); 

} 

Odmah moºemo uo£iti da £lanovi enumeracije imaju ispravno implementiranu 

metodu toString koja vra¢a ime £lana. 

Konstrukcija switch op¢enito se ne moºe koristiti za referentne vrste, ali 

posebno je omogu¢ena za enumeraciju, ²to znatno olak²ava zapis koda kao 

u sljede¢em primjeru: 

Ispis 2.5: Kori²tenje enumeracije u bloku switch 

static void printSuitInCroatian( Suit suit ) 

{ 

String suitName; 

switch ( suit ) 

{ 

case clubs: suitName = "tref"; break; 

} 

case diamonds: suitName = "karo"; break; 

case hearts: suitName = "herc"; break; 

case spades: suitName = "pik"; break; 

default: suitName = ""; 

} 

System.out.println( "Boja karte je " + suitName ); 


{ 

printSuitInCroatian( Suit.clubs ); 

printSuitInCroatian( Suit.hearts ); 

} 

Da nema mogu¢nosti kori²tenja bloka switch, morali bismo pisati ovako:


if ( suit == Suit.clubs ) 

suitName = "tref"; 

else if ( suit == Suit.diamonds ) 

suitName = "karo"; 

else if ( suit == Suit.hearts ) 

suitName = "herc"; 

else if ( suit == Suit.spades ) 

suitName = "pik"; 

else 

suitName = ""; 

Primijetimo da je £lanove enumeracije uvijek sigurno usporeživati po referenci, 

operatorom ==, jer je njihova priroda takva da su svaka dva distinktna 

£lana mežusobno razli£iti. Dodatna prednost konstrukcije switch je u tome 

²to omogu¢uje prevoditelju da nas upozori ako smo slu£ajno izostavili neki 

£lan enumeracije. 

Sve enumeracije implementiraju i su£elje Comparable (vidjeti odjeljak 

5.6.1). Izmežu £lanova enumeracije utvržen je poredak koji odgovara poretku 

kojim su navedeni u deniciji enumeracije. To nam omogu¢uje da 

napi²emo npr. ovakav kod: 


{ 

Suit suit1, suit2; 

suit1 = Suit.clubs; 

suit2 = Suit.hearts; 

int difference = suit1.compareTo( suit2 ); 

if ( difference == 0 ) 

System.out.println( "Boje su iste" ); 

else if ( difference > 0 ) 

System.out.println( "Prva boja pobježuje!" ); 

else 

System.out.println( "Druga boja pobježuje!" ); 

} 

Kao i ostale klase, i enumeraciju je mogu¢e pro²irivati dodatnim atributima 

i metodama. U na²em slu£aju mogli bismo npr. dodati hrvatsko ime 

boje: 


public enum Suit 

{ 

clubs( "tref" ), 

diamonds( "karo" ), 

Ispis 2.6: Oboga¢ena enumeracija


} 

hearts( "herc" ), 

spades( "pik" ); 

private String croName; 

private Suit( String name ) 

{ 

this.croName = name; 

} 

public String getCroName() 

{ 

return this.croName; 

} 

Ovdje smo dodali instancin atribut croName, odgovaraju¢i (privatni!) 

konstruktor i metodu getCroName. Uz ovako deniranu enumeraciju izvedba 

metode printSuitInCroatian postaje trivijalna: 

static void printSuitInCroatian( Suit suit ) 

{ 

System.out.println( "Boja karte je " + suit.getCroName() ); 

} 

2.5 Konstrukcije za upravljanje slijedom izvr- 

²avanja 

Jezik Java raspolaºe upravlja£kim konstrukcijama poznatim iz jezika C: if, 

while, do-while, for i switch. Ovdje ¢e one biti prikazane samo u najkra¢im 

crtama, kroz minimalisti£ki primjer. 

Ispis 2.7: Kratki primjeri uporabe upravlja£kih konstrukcija 

static void controlStructures() 

{ 

int j = 0, k = 1; 

if ( j == k ) 

{ 

k++; 

} 

else if ( j < k ) 

{ 

j++; 

} 

else


k = 0; 

//------------------------------------- 

for ( int i = 0; i < 5; i++ ) 

{ 

if ( i == j - 2 ) 

continue; 

j += i; 

if ( j > 3 ) 

break; 

} 

//------------------------------------- 

while ( j < 13 ) 

j++; 

//------------------------------------- 

do 

{ 

k++; 

} while ( k < 13 ); 

//------------------------------------- 

switch ( j ) 

{ 

case 0: 

k++; 

break; 

case 1: 

j++; 

break; 

default: 

j = k - j; 

} 

} 

Posebnu pozornost zahtijevaju jedino naredbe za izvanredan prekid petlje 

(break) ili izravan pomak na sljede¢i korak petlje (continue), pogotovo 

u kombinaciji s ugnijeºženim petljama. Kori²tenjem oznaka (eng. label) 

mogu¢e je npr. u unutarnjoj petlji narediti izlazak iz vanjske petlje. To je 

demonstrirano ovim primjerom: 

Ispis 2.8: Izjave break i continue koje koriste oznake 

static void breakContinue() 

{ 

outerLoop: 

for ( int i = 1; i < 4; i++ ) 

{ 

for ( int j = 1; j < 4; j++ ) 

{ 

if ( i - j == -1 ) 

continue outerLoop; 

if ( i % j == 1 ) 

break outerLoop;


} 

} 

System.out.println( "i = " + i + ", j = " + j ); 

O£ekivani ispis je: 

i = 1, j = 1 

i = 2, j = 1 

i = 2, j = 2 

i = 3, j = 1 

Ove konstrukcije uvedene su u jezik Javu kao zamjena za naj£e²¢i slu£aj 

kori²tenja naredbe goto, koja ne postoji u jeziku. 

2.6 Sve razine dostupnosti 

Dosad smo se susreli s tri razine dostupnosti: 

• privatna £lan je dostupan samo u klasi gdje je deniran; 

• paketno-privatna £lan je dostupan iz svih klasa u istom paketu; 

• javna £lan je dostupan bez ograni£enja. 

Java poznaje jo² jednu razinu, ²iru od paketno-privatne koja dodatno 

dozvoljava dostup iz svake potklase, bez obzira u kojem paketu se nalazila. 

Pristup je jo² uvijek zabranjen klasama iz drugih paketa ako nisu potklase. 

Ova razina dostupnosti nazna£uje se klju£nom rije£i protected. Koristi se 

prvenstveno u klasi koja je posebno namijenjena da korisnik paketa iz nje 

izvodi svoje klase. Sveukupno, razine dostupnosti mogu se sistematizirati 

tablicom 2.1. 

Tablica 2.1: Pregled razina dostupnosti 

razina (eng.) klasa paket potklase ostali 

private o 

package-private o o 

protected o o o 

public o o o o


2.6.1 Model klasne enkapsulacije 

Java koristi model enkapsulacije koji je zasnovan ne na instanci, ve¢ na 

klasi. Ako je npr. neki atribut ozna£en kao private, to zna£i da je on privatan 

za sve instance te klase i nedostupan instancama drugih klasa. Drugim 

rije£ima, sve instance iste klase mežusobno imaju neograni£en dostup atributima 

i metodama. Na primjer, ovaj kod ne¢e proizvesti prevoditeljsku 

pogre²ku: 

class Abc { 

private int i; 

} 

Ispis 2.9: Model klasne enkapsulacije 

public void manipulateAnotherObject( Abc anotherObject ) 

{ 

anotherObject.i++; 

} 

Ovakav model, iako nije striktno u duhu paradigme objekata s nedodirljivom 

unutra²njosti, u praksi je opravdan jer je sav kod koji moºe manipulirati 

privatnim dijelovima drugog objekta lociran na istom mjestu pa se 

ne mogu pojaviti problemi zbog kojih je i uvedena enkapsulacija da kod 

koji koristi neki objekt prestane funkcionirati zbog izmjena na njegovim 

unutarnjim detaljima. 

2.7 Stati£ka metoda izuzeta od polimorzma 

Modikator static ve¢ je usputno spomenut i kori²ten u ispisima koda uz 

posebnu metodu main. Njime je mogu¢e ozna£iti i bilo koju drugu metodu. 

Time se postiºe da se takva metoda ne poziva nad nekom instancom, ve¢ 

samostalno. Dakle, ne prosliježuje joj se implicitni argument this (vidjeti 

odjeljak 2.11). Argument this klju£an je za funkcioniranje polimorzma i 

bez njega ne moºe do¢i do dinami£kog povezivanja. 

Takva metoda odgovara pojmu funkcije iz proceduralne paradigme (kao 

npr. u jezicima C ili Pascal). Za stati£ke metode koristi se stati£ko povezivanje 

tijekom izvr²avanja ne donosi se odluka koju metodu pozvati, to 

je ksirano u trenutku prevoženja. Za stati£ke metode ponekad se koristi i 

izraz metoda klase odnosno klasina metoda jer je vezana uz klasu, a ne uz 

njene instance.


U ovoj skripti ponekad ¢e se koristiti stati£ke metode, u primjerima za 

koje dinami£ko povezivanje nije bitno. Podru£ja primjene u praksi: 

• Kad su parametri metode instance tužih klasa koje samo koristimo, 

a ne razvijamo pa nemamo dostup njihovom izvornom kodu i ne 

moºemo dodati svoju metodu. Takva primjena zna£ajno je oteºana 

gubitkom dinami£kog povezivanja. 

• Kad su svi parametri primitivne vrste. U tom slu£aju dinami£ko povezivanje 

ionako ne dolazi u obzir. Ovakva primjena prikazana je u 

primjeru koji slijedi malo niºe. 

• Kad metoda ne ovisi ni o jednom parametru. Tada jednostavno nema 

razloga za²to ne bi bila stati£ka, a stati£ko povezivanje je ekasnije 

od dinami£kog. 

Studenti ponekad, ugledaju¢i prevoditeljevu pogre²ku Instance method 

used in a static context, problem otklanjaju progla²avanjem metode stati£kom 

i time zapravo samo stvaraju dodatne probleme. Pogre²ku treba 

otkloniti tako da se jasno ustanovi nad kojom instancom je metoda trebala 

biti pozvana i da se kod ispravi u skladu s time. 

Ako se stati£ka metoda poziva iz neke druge klase, poziv se zapisuje u 

obliku Klasa.stati£kaMetoda: 

Ispis 2.10: Poziv stati£ke metode 

public class BooleanFunctions 

{ 

public static boolean implies( boolean left, boolean right ) 

{ 

return !( left && !right ) ; 

} 

} 

public class Executable 

{ 


{ 

boolean a = true, b = false; 

boolean result = BooleanFunctions.implies( a, b ); 

System.out.println( "" + a + " implies " + b + "? " + result ); 

} 

} 

Ispis:


true implies false? false 

Specikacija jezika Java [4] dozvoljava i poziv stati£ke metode istom 

sintaksom kao da je instancina metoda, npr: 

Ispis 2.11: Poziv stati£ke metode sintaksom kao da je instancina metoda 

public class Executable 

{ 


{ 

boolean a = true, b = false; 

BooleanFunctions bf = null; 

boolean result = bf.implies( a, b ); 

System.out.println( "" + a + " implies " + b + "? " + result ); 

} 

} 

Prevoditelj utvržuje vrstu izraza lijevo od to£ke i ta vrsta mora biti 

klasa u kojoj je denirana doti£na metoda. Ovaj na£in zapisa ne treba 

nikada koristiti jer samo zavarava, a ne donosi nikakve dodatne prednosti 

(nema polimorzma). Primijetimo da je u gornjem primjeru metoda 

pozvana putem varijable £ija vrijednost je null, £ime se jasno demonstrira 

da se potpuno ignorira vrijednost varijable, bitna je samo njena vrsta. 

2.8 Stati£ki atribut, konstanta 

Sli£no kao metoda, atribut isto moºe biti stati£ki i time nevezan uz instancu. 

Postoji samo jedna, globalna vrijednost takvog atributa. Jedna od naj£e²¢ih 

uporaba stati£kih atributa je za deniranje konstanti, npr. mogli bismo u 

konstanti denirati podrazumijevanu duljinu ciklusa broja£a ModuloCounter: 

Ispis 2.12: Stati£ki atribut, javna konstanta 


{ 

public static final int DEFAULT_MODULUS = 10; 

private int modulus; 


{ 

this.modulus = DEFAULT_MODULUS; 

} 

... 

}


2.8.1 Modikator final rekapitulacija 

Pri deniranju konstante pojavljuje se i modikator final. U odjeljku 1.11 

obja²njeno je kako se on primjenuje na metode i klase radi kontrole polimorzma. 

Na atribute i varijable djeluje tako da zabranjuje promjenu njihove 

vrijednosti nakon inicijalizacije. Njime se, ako zatreba, moºe ozna£iti 

i parametar metode, npr. 

public void increment( final int step ) 

{ ... } 

Kori²tenjem modikatora final na svim varijablama gdje je to smisleno 

pove¢ava se £itljivost koda jer se time jasno nagla²ava da se ustvari radi 

o konstanti. U praksi velik broj, a moºda i ve¢ina varijabli imaju ulogu 

konstante. 

2.9 Pravila oblikovanja identikatora 

U jeziku Java na snazi su neformalna, ali vrlo snaºna pravila oblikovanja 

identikatora, od kojih se ne smije odudarati. Naj£vr²¢a pravila ti£u se 

rasporeda velikih i malih slova: 

• U imenu paketa zabranjeno je koristiti velika slova. Npr. ime 

paketa kori²tenog u primjerima je hr.fer.tel.jsem. 

• Ime referentne vrste podatka (klasa i su£elje) obavezno po£inje 

velikim slovom. Svaka daljnja rije£ u imenu ponovo po£inje velikim 

slovom. Npr. SimpleCounter. 

• Ime lokalne varijable, parametra, uhva¢ene iznimke, atributa i metode 

obavezno po£inje malim slovom. Svaka daljnja rije£ u imenu po- 

£inje velikim slovom. Npr. counterState. 

• Poseban slu£aj su javne konstante, koje se pi²u velikim slovima, a 

rije£i se odvajaju podvlakom. Npr. DEFAULT_MODULUS. 

Za sve identikatore koristi se isklju£ivo engleski jezik. Za su£elje 

se uvijek odabire najkra¢e, naj£i²¢e ime bez posebnih preksa ili suksa 

kao u na²em primjeru Counter. To je stoga ²to se upravo ime su£elja 

najvi²e koristi u kodu. Ime apstraktne klase u vrhu hijerarhije uobi£ajeno


je napraviti od imena su£elja s preksom Abstract npr. AbstractCounter. 

Konkretne klase uobi£ajeno zadrºavaju ime svog su£elja na zadnjem mjestu, 

a naprijed se dodaju rije£i koje pobliºe opisuju o kakvoj implementaciji se 

radi npr. ModuloCounter. 

2.10 Upcast i downcast 

Op¢enito, pojam type cast odnosi se na tretiranje podatka jedne vrste kao 

da je neke druge. U nekim drugim jezicima, prije svega C-u, mogu¢e je 

cast-ati izmežu vrsta na razli£ite na£ine na primjer, cijeli broj mogu¢e 

je cast-ati u pokaziva£. Za referentne vrste jedini dozvoljeni oblik castanja 

je unutar klasne hijerarhije ili prema gore (upcast), ili prema dolje 

(downcast). 

Slu£aj upcast-a je jednostavniji i dogaža se automatski. Tako se naziva 

situacija s kojom smo se ve¢ sreli na primjer, kad se instanca klase 

SimpleCounter tretira kao instanca su£elja Counter (u ispisu 1.13). Isto se dogaža 

i kad imamo dvije klase u odnosu natklasa-potklasa. Dakle, upcast je 

tehni£ko sredstvo koje omogu¢ava transparentno kori²tenje polimorzma. 

Njega je uvijek sigurno provesti ne moºe se dogoditi da instanca potklase 

nema neku metodu deniranu za natklasu. 

Java dozvoljava i cast-anje u suprotnom smjeru, prema dolje po hijerarhiji 

downcast. Njega se ne koristi da bismo instancu natklase tretirali kao 

instancu potklase dapa£e, to bi prouzro£ilo pogre²ku jer potklasa moºe 

imati dodatne metode koje natklasa nema. Downcast sluºi da bi se npr. u 

metodi koja prima op¢eniti parametar (npr. Counter) ipak mogla koristiti 

puna funkcionalnost instance konkretne klase (npr. ModuloCounter). Uzmimo 

konkretan primjer recimo da klasa ModuloCounter (ispis 1.21) ima dodatnu 

metodu setModulus koja nije denirana u su£elju Counter jer je speci£na za 

slu£aj cikli£kog broja£a: 

Ispis 2.13: ModuloCounter s dodatnom metodom setModulus 




{ 

private int modulus = 10; 

public ModuloCounter( int initialState )


{ 

} 


} 


{ 

} 

public void setModulus( int newModulus ) 

{ 

this.modulus = newModulus; 

} 


{ 

this.counterState = newState % this.modulus; 

} 

Nadalje, recimo da negdje imamo metodu koja prima parametar op¢enite 

vrste Counter, ali u slu£aju da se radi o cikli£kom broja£u, ºeli postaviti 

duljinu ciklusa na potrebnu vrijednost: 

Ispis 2.14: Metoda koja upravlja ModuloCounter-om 

public static void useCounter( Counter cntr ) 

{ 

ModuloCounter modCntr = (ModuloCounter) cntr; 

modCntr.setModulus( 7 ); 

} 

Varijabli vrste ModuloCounter pridjeljuje se vrijednost parametra vrste 

Counter i stoga je potrebno eksplicitno provesti downcast izrazom 

(ModuloCounter) cntr 

2.10.1 Operator instanceof 

U slu£aju da obavimo downcast nad objektom koji nije instanca doti£ne 

klase (ili eventualno njena potklasa), tijekom izvr²avanja programa bit ¢e 

prijavljena pogre²ka. U trenutku kompilacije op¢enito nije mogu¢e ustanoviti 

ho¢e li se to dogoditi. Na primjer, ako imamo ovakav poziv metode 

useCounter: 

useCounter( new SimpleCounter() );


jasno je da mora do¢i do pogre²ke jer klasa SimpleCounter ne denira metodu 

setModulus. Java ne¢e dozvoliti ni da kod stigne do tog poziva jer ¢e 

prijaviti pogre²ku ve¢ prilikom poku²aja downcast-anja. Prekid izvr²avanja 

zbog pogre²ke moºe se izbje¢i obavljanjem prethodne provjere operatorom 

instanceof: 

Ispis 2.15: Doražena metoda useCounter 

public static void useCounter( Counter cntr ) 

{ 

if ( cntr instanceof ModuloCounter ) 

{ 

ModuloCounter modCntr = (ModuloCounter) cntr; 

modCntr.setModulus( 7 ); 

} 

} 

Prije nego ²to se obavi downcast, provjerava se je li prosliježen objekt 

zaista instanca klase ModuloCounter. Operator instanceof s lijeve strane op- 

¢enito ima neki izraz £ija vrijednost je referentne vrste, a s desne strane 

doslovno navedeno ime neke referentne vrste (klase ili su£elja). Operator 

vra¢a true ako je lijevi operand instanca desnog operanda ili njegove potklase. 

Odnosno, ako je desni operand su£elje, provjerava je li lijevi operand 

objekt koji implementira to su£elje. U praksi, u ve¢ini slu£ajeva gdje se radi 

downcast potrebna je ovakva provjera. 

2.11 Implicitni parametar metode this 

Ve¢ smo se na samom po£etku, u ispisu 1.1, susreli s klju£nom rije£i this 

pomo¢u koje smo u kodu metode pristupali atributima objekta nad kojim 

je ona pozvana. Formalno, svaka instancina metoda (metoda objekta, 

tj. svaka koja nije stati£ka), osim eksplicitno navedenih parametara, prima 

implicitno i dodatni parametar £ije ime je this, vrsta mu je klasa u kojoj 

se metoda nalazi, a vrijednost referenca na objekt nad kojim je metoda 

pozvana. Na primjer, metodu increment iz ispisa 1.16 (deklaracija klase 

SimpleCounter) mogli smo zapisati i ovako, zadrºavaju¢i identi£no pona²anje: 


Ispis 2.16: Implicitni parametar this


{ 

} 

SimpleCounter cntr = this; 

cntr.counterState++; 

Prilikom poziva metode, npr. cntr1.increment() u ispisu 1.4, referenca 

iz varijable cntr1 prepisujse se u parametar this. 

2.11.1 Parametar this i polimorzam 

Ono ²to je najvaºnije za parametar this je da upravo on omogu¢uje funkcioniranje 

polimorzma jer se samo za njega provodi dinami£ko povezivanje. 

Tijekom izvr²avanja programa prije svakog poziva metode prvo se provjerava 

to£na vrsta objekta na koji ¢e pokazivati this. Na osnovu te vrste 

donosi se odluka koju metodu pozvati. Za sve ostale, obi£ne parametre 

vrsta se ne utvržuje prilikom izvr²avanja, ve¢ samo prilikom prevoženja 

i to na osnovu deklarirane vrste izraza koji se pojavljuju kao argumenti 

metode. Drugim rije£ima, stati£ki se ustanovljuje potpis pozvane metode 

(vidjeti odjeljak 1.12). 

Bez ovog saznanja mogli bismo pomisliti da su npr. ova dva pristupa 

deniranju metode increment ekvivalentni (modikator static narežuje da 

se ne proslijedi implicitni parametar this, vidjeti odjeljak 2.7): 

Ispis 2.17: Neuspio poku²aj uvoženja eksplicitnog parametra this 


{ 


void incrementWithExplicitThis( Counter explicitThis ); 

... ostale metode ... 

} 



{ 



{ 


} 

public static void incrementWithExplicitThis( Counter explicitThis ) 

{ 

explicitThis.counterState++;


} 

} 

... ostale metode ... 

Metode bismo mogli poku²ati koristiti ovako: 

Ispis 2.18: Neuspio poku²aj kori²tenja metode s eksplicitnim this 


{ 

Counter cntr = new SimpleCounter(); 


Counter.incrementWithExplicitThis( cntr ); 

} 

Naoko, situacija je ekvivalentna prvi put se argument metode navodi 

lijevo od to£ke, a drugi put kao normalni argument u zagradama. Mežutim, 

uvoženje metode incrementWithExplicitThis ustvari generira £itav niz 

prevoditeljevih pogre²aka, sve zbog toga ²to Java ne provodi dinami£ko 

povezivanje nad normalnim argumentima. 

Prilikom prevoženja poziva incrementwithExplicitThis( cntr ) utvržuje 

se da je deklarirana (stati£ka) vrsta argumenta cntr jednaka Counter. Tu se 

nigdje ne pojavljuje prava vrsta objekta, SimpleCounter, i Java uop¢e ne¢e 

uzeti u obzir tu klasu. Dakle, nemogu¢e je da ¢e se pozvati metoda iz klase 

SimpleCounter. Vrsta Counter je ustvari su£elje u kojem uop¢e nema denicija 

metoda. Jasno je dakle da je ovakva situacija nemogu¢a i da mora 

uzrokovati prevoditeljevu pogre²ku. U praksi, prevoditeljeva pogre²ka pojavit 

¢e se ve¢ £im metodu incrementwithExplicitThis ozna£imo kao static 

jer je to metoda su£elja, a metode su£elja nikad nisu stati£ke iz upravo 

obja²njenog razloga. 

Nadalje, £ak i da se svi ovi problemi na neki neobja²njeni na£in rije²e 

i da zaista bude pozvana metoda incrementwithExplicitThis u klasi 

SimpleCounter, tamo stoji izjava explicitThis.counterState++. Parametar explicitThis 

je vrste Counter, a u toj vrsti ne spominje se nikakav atribut 

counterState i stoga ¢e se i za to prijaviti prevoditeljeva pogre²ka. 

Jo² jedan primjer u kojem se o£ituje razlika izmežu parametra this i 

ostalih moºe se vidjeti u raspravi u odjeljku 3.2.1. 

Pojam koji se u struci koristi za proces dinami£kog povezivanja je method 

dispatch. Za Javu se stoga kaºe da podrºava samo single dispatch jer


obavlja dispatch po samo jednom parametru metode. Suprotan pojam je 

multiple dispatch. 

Stru£ni pojam za jezi£no svojstvo da se prilikom prevoženja, tj. stati£ki 

utvržuju vrste svih izraza je static typing. Java je, dakle, statically typed 

jezik. Suprotan pojam je dynamic typing. 

2.12 Detalji o hijerarhiji klasa 

2.12.1 Korijenska klasa Object 

U 1. poglavlju ve¢ se govorilo o izvedenim klasama. U Javi je svaka klasa izvedena 

iz to£no jedne klase, osim posebne ugražene klase java.lang.Object, 

koja nema natklasu. Ako nacrtamo detaljan UML-ov dijagram klasa prikazuju¢i 

sve veze izvedena iz, dobit ¢emo stablo £iji korijen je klasa java.lang.Object. 

Ako deklaracija klase ne navodi eksplicitno iz koje je klase izvedena, podrazumijeva 

se extends java.lang.Object. Klasa Object denira i neke metode 

koje stoga imaju svi objekti (vidjeti 3.2). 

Graf odnosa implementira su£elje s druge strane, jest hijerarhija, ali 

nije stablo. Jedna klasa moºe implementirati proizvoljan broj su£elja, a i 

su£elje moºe biti izvedeno iz proizvoljnog broja drugih su£elja. 

2.12.2 Denicije izraza vezanih uz hijerarhiju 

Kad se pri£a o hijerarhijskim odnosima izmežu klasa, treba imati na umu 

to£na zna£enja izraza kao ²to su natklasa i potklasa. Vrijede sljede¢e denicije: 

• Natklasa klase C je klasa B iz koje je ona izvedena, ali takožer i klasa 

A iz koje je izvedena B, itd. Koriste¢i izraze iz genealogije, natklasa 

odgovara pojmu pretka. Klasa Object je, dakle, natklasa svim ostalim 

Javinim klasama. 

• Potklasa klase A je, analogno, svaka klasa-potomak, tj. svaka klasa B 

kojoj je A natklasa. 

• Klasa-roditelj klase C je njena izravna natklasa ona iz koje je izvedena.


• Klasa-dijete klase C je svaka klasa koja je iz nje izvedena, tj. kojoj je 

klasa C roditelj. 

2.12.3 Ulan£avanje poziva konstruktora 

Svaki konstruktor, prije nego ²to se izvr²i njegov kod, duºan je prvo pozvati 

neki konstruktor svoje natklase. To se dogaža ili eksplicitno, kori²tenjem 

klju£ne rije£i super, ili, u odsustvu toga, implicitno se dodaje poziv podrazumijevanog 

konstruktora natklase (super()). Posljedica toga je da se 

konstruktori izvr²avaju ulan£ano, tako da se prvo uvijek izvr²i konstruktor 

klase Object, zatim kontruktor neke njene izravne potklase, itd. sve do 

konkretne klase koja se instancira. Zbog toga £ak i za apstraktne klase, 

koje se ne smiju instancirati, vrijede ista pravila o posjedovanju bar jednog 

konstruktora. Bez toga bi bilo nemogu¢e instancirati njihove potklase. 

Imaju¢i re£eno u vidu, moºemo uvidjeti da je puni oblik dvaju konstruktora 

u ispisu 1.20 ustvari ovakav: 

Ispis 2.19: Eksplicitan poziv konstruktora natklase 


{ 

super(); 


} 


{ 

super(); 

} 

Implicitne pozive treba uvijek imati na umu, posebice stoga ²to natklasa 

ne mora posjedovati podrazumijevani konstruktor. Ako dakle imamo konstruktor 

s izostavljenim pozivom konstruktora natklase, a natklasa nema 

podrazumijevani konstruktor, do¢i ¢e do pogre²ke prilikom prevoženja koja 

moºe biti prili£no zbunjuju¢a jer se dogodila u praznom prostoru u koji 

je implicitno dodan izostavljeni poziv super(). 

Konstruktor moºe umjesto iz natklase pozvati i neki drugi konstruktor 

iz iste klase. Time je omogu¢ena vi²estruka iskoristivost koda u vi²e 

konstruktora. U kona£nici, nakon ²to se konstruktori klase mežusobno dogovore 

koji ¢e se prvi izvr²iti, taj konstruktor opet poziva konstruktor iz


natklase. Poziv susjednog konstruktora postiºe se kori²tenjem klju£ne rije£i 

this umjesto super. Na primjer, konstruktore u ispisu 1.20 mogli smo 

denirati i ovako: 

Ispis 2.20: Poziv konstruktora iste klase 


{ 

super(); 


} 


{ 

this( 0 ); 

} 

Kori²tenjem podrazumijevanog konstruktora AbstractCounter() prvo ¢e 

se izvr²iti podrazumijevani konstruktor natklase (super()), zatim ostatak 

konstruktora s jednim parametrom, a zatim ostatak podrazumijevanog 

konstruktora (u ovom slu£aju nema daljnjih akcija u njemu). 

Napomenimo na kraju da kori²tenje klju£nih rije£i super i this za pozive 

konstruktora nema nikakve veze s kori²tenjem istih klju£nih rije£i u 

smislu reference na trenutni objekt i pozivanja metode natklase. Radi se 

samo o ²tednji na klju£nim rije£ima njihovim vi²estrukim kori²tenjem u 

jeziku. Svaka dodatna klju£na rije£ zna£i jo² jedan zabranjeni identikator 

za varijable, metode itd. 

2.13 Java kao softverska platforma 

Pod pojmom Java ne podrazumijeva se samo programski jezik i njegova 

biblioteka klasa, nego i cjelokupna softverska platforma, £iji temelj je Javin 

virtualni stroj. 

Programi napisani u Javi ne prevode se, kao ²to je ina£e uobi£ajeno, 

u izvr²ni kod koji se izravno moºe izvr²avati na procesoru ra£unala, ve¢ 

u posebnu vrstu izvr²nog koda za Javin virtualni stroj (JVM), koji onda 

konkretno ra£unalo emulira. Taj poseban binarni kod naziva se mežukodom 

ili byte-kodom (eng. bytecode). Cilj toga je postizanje neovisnosti o ra£unalskoj 

platformi: kod se kompilira jednom, a izvr²ava na bilo kojem stroju 

koji ima implementaciju JVM-a, bez obzira na vrstu procesora. Takožer 

se tehni£ki omogu¢uje i bolja kontrola nad interakcijom izmežu Javinog


programa i ra£unala na kojem se izvr²ava. Lak²e je mogu¢e blokirati svaki 

poku²aj pristupa osjetljivim resursima i tako onemogu¢iti zlonamjerni kod. 

Vi²e o ovome moºe se doznati na [5]. 

Sve ovo potje£e od prvotnog cilja Jave da sluºi za tzv. embedded applications, 

aplikacije koje se u£itavaju unutar webskih stranica. ƒim se ne²to 

implicitno u£itava putem Weba, otvara se prostor za napade na ra£unalo 

pisanjem zlonamjernog koda. U mežuvremenu se Java po£ela masovno koristiti 

i za pisanje obi£nih, samostojnih aplikacija, gdje je pitanje sigurnosti 

manje bitno. Na primjer, £itavo razvojno okruºje Eclipse, kao i Borlandov 

JBuilder, napisani su u Javi.

Poglavlje 3 

Najvaºnije ugražene klase 

Ve¢ je re£eno da jezik Java sadrºi i ve¢i broj ugraženih klasa i su£elja. Takožer 

je istaknut i jedan od ugraženih paketa koji je posebno usko povezan 

s jezikom paket java.lang. Ovdje ¢e biti izloºeni detalji nekoliko najvaºnijih 

klasa iz tog paketa. Za daljnje detalje treba se obratiti dokumentaciji 

Javine biblioteke klasa dostupne na Webu [1]. 

3.1 Uvodne upute za snalaºenje u Javinoj dokumentaciji 

API-ja 

Javin sustav za HTML-ovsku dokumentaciju zove se Javadoc. Na primjer, 

na upravo spomenutoj internetskoj lokaciji, [1], nalazi se Javadoc-ova dokumentacija 

cjelokupne Javine biblioteke klasa. Kad otvorimo tu lokaciju 

u pregledniku Weba, dobit ¢emo prikaz kao na slici 3.1. Pregled treba zapo£eti 

u okviru gore lijevo. Tamo je popis svih paketa. Treba kliknuti na 

paket od interesa, u ovom slu£aju java.lang. Time se u okviru dolje lijevo 

suºava izbor i prikazuju se samo klase iz doti£nog paketa. U tom okviru 

zatim moºemo na¢i klasu koja nas zanima, npr. Object. U glavnom okviru 

(desno) pojavljuje se dokumentacija traºene klase. Na vrhu je op¢eniti opis 

klase, a zatim slijedi popis £lanova konstruktora, atributa i metoda. Prvo 

su u tablicama pobrojani svi £lanovi s kratkom napomenom. Klikom na 

ime £lana odlazi se dublje u stranicu, gdje je njegov detaljan opis. Na slici 

3.2 prikazana je detaljna dokumentacija za metodu equals. 

59

60 POGLAVLJE 3. NAJVAšNIJE UGRAÐENE KLASE 

Slika 3.1: Po£etna stranica Javadoc-a

POGLAVLJE 3. NAJVAšNIJE UGRAÐENE KLASE 61 

Slika 3.2: Dokumentacija za metodu equals


3.2 Klasa java.lang.Object 

Klasa Object je u korijenu Javine hijerarhije klasa, kao ²to je napomenuto 

u odjeljku 2.12.1. Ovdje ¢e se detaljnije govoriti o toj klasi. To nije kao 

²to bi se moglo pomisliti za najop¢enitiju klasu koja predstavlja bilo kakav 

objekt samo prazna, apstraktna klasa bez svojih funkcionalnosti. Radi 

se o konkretnoj klasi koju je mogu¢e normalno instancirati. Osim toga 

je i prili£no kompleksna i njena implementacija je vezana uz £itav niz programskih 

tehnika. Ovdje ¢e se od svega spominjati samo njene najosnovnije 

karakteristike. 

3.2.1 Metoda equals 

U odjeljku 2.1.2 spomenuto je da za provjeru jednakosti objekata treba 

koristiti metodu equals. Metodu se koristi tako da ju se pozove nad prvim 

objektom i kao argument se proslijedi drugi objekt: o1.equals( o2 ). Metoda 

equals denirana je u klasi Object, ali na trivijalan na£in usporežuju 

se reference (o1 == o2). Ako je potrebna smislena usporedba objekata neke 

klase, potrebno je nadja£ati ovu metodu odgovaraju¢om implementacijom. 

Potpis metode je equals( Object ) i upravo takvu metodu moramo dodati 

u svoju klasu. Budu¢i da je parametar vrste Object, prvo ¢e biti potrebno 

ustanoviti je li prosliježeni objekt odgovaraju¢e vrste jer ako nije, onda 

je jasno da nije jednak trenutnom objektu. Stoga kod ove metode rutinski 

zapo£inje kori²tenjem operatora instanceof, iza £ega slijedi odgovaraju¢i 

downcast. Na primjer, mogli bismo imati ovakav equals u klasi SimpleCounter 

(ispis 1.21): 




{ 

... sve isto kao ranije ... 

Ispis 3.1: Implementacija metode equals 

public boolean equals( Object o ) 

{ 

if ( !( o instanceof SimpleCounter ) ) 

return false; 

SimpleCounter that = (SimpleCounter) o;


} 

} 

return this.counterState == that.counterState; 

Za metodu equals tipi£no je da se okori²tava klasnom enkapsulacijom i da 

izravno pristupa atributima drugog objekta. 

Jedna od tipi£nih pogre²aka kod studenata je deklaracija metode s parametrom 

£ija vrsta je trenutna klasa (npr. equals( SimpleCounter )). Parametar 

mora biti vrste Object, u protivnom se ne¢e raditi o nadja£avanju, 

ve¢ o deniranju nove metode koja samo preoptere¢uje ime equals. U 

jednostavnim primjerima kod ¢e £ak ispravno raditi jer ¢e se pozivati ta 

metoda umjesto prave metode equals. Sljede¢i primjer pokazuje u kojem 

slu£aju ¢e raditi, a u kojima ne: 

Ispis 3.2: Tipi£na pogre²ka s preoptere¢enjem umjesto nadja£avanjem 

public class EqualsTester 

{ 

public boolean equals( EqualsTester et ) 

{ 

return true; 

} 


{ 

EqualsTester et1 = new EqualsTester(); 

EqualsTester et2 = new EqualsTester(); 

boolean b; 

b = et1.equals( et2 ); 

System.out.println( b ); // true 

// upcast argumenta na vrstu Object: 

Object o2 = et2; 

b = et1.equals( o2 ); 

System.out.println( b ); // false! 

} 

} 

// upcast objekta nad kojim se poziva metoda: 

Object o1 = et1; 

b = o1.equals( et2 ); 

System.out.println( b ); // false! 

Kad god se ispi²e false, zna£i da je pozvana originalna metoda equals 

iz klase Object, koja je ostala nenadja£ana. Razlog za ovakvo pona²anje, 

koje se nekima moºe £initi nelogi£nim s obzirom na postojanje dinami£kog


povezivanja, je u tome ²to se dinami£ko povezivanje provodi samo nad parametrom 

this, tj. nad objektom lijevo od to£ke u pozivu metode (vidjeti 

odjeljak 2.11). Vrste argumenata, tj. potpis pozvane metode utvržuje se 

stati£ki, prilikom prevoženja. U prvom pozivu, et1.equals( et2 ) utvrženi 

potpis metode je equals( EqualsTester ) pa se poziva na²a metoda. U drugom 

slu£aju ispada equals( Object ) pa se poziva metoda nasliježena od 

klase Object. 

Tre¢i slu£aj je najsuptilniji. Argument je ponovo vrste EqualsTester 

kao u prvom slu£aju, koji je radio ispravno. Mežutim, sada je izraz lijevo 

od to£ke vrste Object. Prevoditelj u toj klasi traºi sve metode imena equals 

i nalazi samo jednu, s parametrom vrste Object. Na osnovu toga odabire 

se potpis metode equals( Object ). Tek tijekom izvr²avanja uo£it ¢e se da 

je stvarna vrsta objekta lijevo od to£ke EqualsTester, mežutim tada je ve¢ 

ksiran potpis metode koju treba pozvati, i to je equals( Object ) metoda 

nasliježena iz klase Object. 

Problem kao u drugom slu£aju dogaža se uvijek kad se metoda preoptere¢uje 

tako da su vrste parametara u odnosu potklasa-natklasa. Takvo 

preoptere¢enje redovito treba izbjegavati. Ako postoji potreba za takve 

dvije metode, trebaju imati razli£ita imena. Problem kao u tre¢em slu£aju 

ne bi se dogodio da su obje verzije preoptere¢ene metode bile denirane u 

istoj klasi. 

3.2.2 Metoda hashCode 

Ova metoda vezana je uz vrlo zna£ajnu programsku tehniku he²-tablicu 

(eng. hash table ili hashtable). To je struktura koja sluºi za memorijski 

ekasno spremanje ve¢e koli£ine podataka uz sposobnost brzog dohva¢anja 

podatka prema njegovom klju£u he²-kodu. U Javu ugražene kolekcije 

(vidjeti 5. poglavlje) interno koriste he²-tablice (npr. £esto kori²tena klasa 

HashSet). One se oslanjaju na ispravnu implementaciju metode hashCode u 

svakom objektu koji se sprema u kolekciju. Ova metoda usko je povezana 

s metodom equals i njih dvije se uvijek nadja£ava u paru. 

Metoda hashCode zaduºena je da za svaki objekt vrati njegov he²-kod 

u obliku cijelog broja (int-a). Presudno je da dva jednaka objekta uvijek 

prijavljuju i jednak he²-kod. Bitno je i da dva razli£ita objekta ²to £e²¢e 

vra¢aju razli£it he²-kod dakle, da he²-kodovi budu ²to bolje raspr²eni po 

objektima. U protivnom ¢e se degradirati ekasnost he²-tablice. Jasno je


da objekt koji ima vi²e od 2 32 mogu¢ih stanja ne moºe za svako stanje 

prijaviti razli£it he²-kod i stoga je potrebno promi²ljeno implementirati 

ovu metodu da se postigne dobro raspr²enje. Postoji standardni predloºak 

za implementaciju ove metode i najbolje ga se uvijek drºati. U ispisu 3.3 

prikazana je klasa koja sadrºi sve mogu¢e slu£ajeve vrsta podataka i na£in 

izra£una njihovog he²-koda. Ukratko, postupak je sljede¢i: 

1. Deklariramo cjelobrojnu varijablu (u primjeru: hc) i inicijaliziramo ju 

na 17. 

2. Za svaki atribut koji sudjeluje u metodi equals izra£unamo njegov 

he²-kod kao u primjeru. 

3. U varijablu hc ugražujemo pojedini he²-kod atributa prema formuli 

hc = 37*hc + he²-kod 

4. Kona£nu vrijednost varijable hc vratimo kao ukupan he²-kod objekta. 

Ispis 3.3: Predloºak za generiranje he²-koda 

public class HashCodeExample 

{ 

private boolean boolVal; 

private byte byteVal; 

private char charVal; 

private short shortVal; 

private int intVal; 

private long longVal; 

private float floatVal; 

private double doubleVal; 

private Object objVal; 

private int[] intArray = { 1, 2, 3 }; 

public int hashCode() 

{ 

int hc = 17; 

hc = 37*hc + ( boolVal? 1 : 0 ); 

hc = 37*hc + byteVal; 

hc = 37*hc + charVal; 

hc = 37*hc + shortVal; 

hc = 37*hc + intVal; 

hc = 37*hc + (int) ( longVal ^ ( longVal >>> 32 ) ); 

hc = 37*hc + Float.floatToIntBits( floatVal ); 

long dblToLong = Double.doubleToLongBits( doubleVal ); 

hc = 37*hc + (int) ( dblToLong ^ ( dblToLong >>> 32 ) );


hc = 37*hc + objVal.hashCode(); 

for ( int i = 0; i < intArray.length; i++ ) 

hc = 37*hc + intArray[i]; 

} 

} 

return hc; 

3.2.3 Metoda toString 

Pri razvoju programa, posebice tijekom traºenja i uklanjanja pogre²aka, 

program mora ispisivati detalje tijeka izvr²avanja. Na primjer, £esto je potreban 

ispis trenutnog stanja klju£nih objekata prije i nakon neke operacije. 

Takožer, u trenutku kad dože do pogre²ke iznimno je korisno dobiti izvje- 

²taj o stanju objekta koji je izazvao pogre²ku. Za ovakve i druge namjene 

postoji metoda toString koju imaju svi objekti jer je denirana u klasi 

Object. Metoda je zaduºena da vrati znakovni niz koji opisuje objekt. 

Izvorna implementacija u klasi Object prili£no je beskorisna (vra¢a ime 

klase £ija je instanca u pitanju i njen he²-kod u heksadecimalnom zapisu), 

stoga ju je redovito potrebno nadja£ati smislenom implementacijom. Studenti 

ponekad krivo shvate namjenu metode pa ju izvedu tako da sama 

ispisuje na zaslon. Pazite da izbjegnete takvu pogre²ku. Primjer implementacije 

u klasi SimpleCounter (ispis 1.21): 


Ispis 3.4: Implementacija metode toString 



{ 

... sve isto kao ranije ... 

} 

public String toString() 

{ 

return "SimpleCounter:" + this.counterState; 

} 

3.3 Klasa java.lang.String 

U Javi, znakovni nizovi predstavljeni su instancama ugražene klase String. 

Ova klasa integrirana je u sam jezik i postoje jezi£ne konstrukcije posebno


za nju: 

• Doslovno navoženje niza unutar dvostrukih navodnika, npr. "znakovni 

niz". Rezultat ovog izraza je instanca klase String s navedenim tekstom 

kao sadrºajem. Znakovne nizove, dakle, ne kreira se uobi£ajenim 

konstruktorom: new String("znakovni niz"). Ovo dodu²e radi, 

ali se sasvim nepotrebno stvara objekt vi²ka sam niz pod navodnicima 

je jedan objekt, a dodatni se stvara operatorom new. 

• Operator ulan£avanja, npr. "znakovni" + " " + "niz". Rezultat je novi 

String sadrºaja "znakovni niz". U skladu s ovime deniran je i sloºeni 

operator dodjele +=. Znak + koristi se dakle i za zbrajanje i za ulan- 

£avanje. Odluka o tome koji je smisao danog znaka donosi se prema 

vrsti lijevog operanda: ako je to String, operacija je ulan£avanje. U 

sloºenijim izrazima ne mora biti sasvim o£ito ²to je lijevi operand pa 

treba biti na oprezu (npr. ²to je lijevi operand drugog plusa u izrazu 

"a" + 2 + 3? to je izraz "a" + 2, vrste String). Ako se kao operand 

ulan£avanja pojavi ne²to drugo osim String-a, automatski se pretvara 

u odgovaraju¢i String. Ako se radi o objektu, poziva se njegova metoda 

toString, ako se radi o nul-referenci, pretvara se u niz "null", a i 

primitivni podaci se pretvaraju na smisleni na£in. Primjerice, rezultat 

izraza "a" + 2 + 3 je "a23". S druge strane, rezultat izraza 2 + 3 + 

"a" je prevoditeljeva pogre²ka jer se u ovom slu£aju radi o zbrajanju, 

a nizove se ne moºe pribrajati brojevima. Iz ovakve situacije moºemo 

se izvu¢i malim trikom: "" + 2 + 3 + "a" ¢e dati ºeljeni rezultat "23a". 

3.3.1 Provjera jednakosti znakovnih nizova 

Usporeživanje nizova nije na sli£an na£in elegantno integrirano u jezik i 

mora ih se usporeživati kao i ostale objekte, pozivom metode equals. Usporedba 

pomo¢u == samo ¢e usporediti reference, kao i ina£e. Kori²tenje 

pogre²nog na£ina usporedbe moºe izazvati vrlo neobi£no pona²anje ponekad 

ispravno, a ponekad neispravno. To je stoga ²to Java automatski 

optimizira kori²tenje instanci String-a pa moºe vi²estruko iskoristiti istu 

instancu na vi²e mjesta gdje se pojavljuje isti niz. Ako se to dogodi, provjera 

pomo¢u == ¢e pro¢i: 

Ispis 3.5: Posljedice pogre²nog kori²tenja == za usporedbu String-ova



{ 

String a = "a"; 

String b = "b"; 

String ab1 = "ab"; 

String ab2 = "ab"; 

String ab3 = a + b; 

} 

System.out.println( ab1 == ab2 ); // true 

System.out.println( ab1 == ab3 ); // false 

System.out.println( ab1.equals( ab2 ) ); // true 

System.out.println( ab1.equals( ab3 ) ); // true 

U primjeru je konstanta "ab" uspje²no iskori²tena dvaput i za ab1 i za 

ab2. Mežutim, kad taj isti niz sastavimo ulan£avanjem iz druga dva, kreira 

se novi objekt pa referenca na njega vi²e nije ista. 

3.3.2 Nepromjenjivost instanci String-a 

Klasa String dizajnirana je da bude nepromjenjiva (eng. immutable) njene 

instance nikad ne mijenjaju stanje. Ovo svojstvo uvijek je izrazito poºeljno 

za svaku klasu gdje je to mogu¢e. Takvi objekti imaju neka korisna svojstva 

koja ina£e imaju podaci primitivne vrste: 

• Ako se takav objekt proslijedi metodi, nema opasnosti da ¢e ga ona 

izmijeniti i tako neizravno i nepredviženo utjecati na funkciju pozivaju¢e 

metode. 

• Ako je neki od atributa objekta nepromjenjiv objekt, moºe ga se 

dati na raspolaganje vanjskom svijetu bez opasnosti da ga se izvana 

izmijeni i tako neizravno utje£e na stanje objekta koji ga sadrºi. 

• U vi²enitnom programu nema potrebe za sinkronizacijom pristupa 

nepromjenjivom objektu iz vi²e niti. 

Budu¢i da su String-ovi nepromjenjivi, jasno je da se pri svakoj promjeni 

vrijednosti neke String-ovske varijable stvara novi objekt. Npr. izraz 

s += "tri" ne¢e izmijeniti postoje¢i objekt pridijeljen varijabli s, ve¢ ¢e 

stvoriti novi i referencu na njega zapisati u varijablu. Ako u kodu imamo 

situaciju gdje se dogažaju brojne izmjene znakovnih nizova, moºemo radi 

²tednje radne memorije pribje¢i kori²tenju druge klase, StringBuffer, koja


modelira promjenjivi niz. U tom slu£aju, mežutim, ne¢emo se mo¢i koristiti 

elegantnim jezi£nim konstrukcijama kao kad radimo sa String-om. 

3.4 Klasa System 

Ova klasa ne sluºi za instanciranje, ve¢ sadrºi korisne stati£ke metode i 

atribute koji ostvaruju vezu s uslugama ra£unalske platforme na kojoj se 

izvr²ava Javin program. Pregled najvaºnijih £lanova klase: 

• atributi in, out i err: veza na standardni ulaz, izlaz i izlaz za pogre²ke. 

Vidjeti 7.3 

• metoda currentTimeMillis: trenutno sistemsko vrijeme 

• metoda exit( int ): prekid izvr²avanja programa. Prosliježeni broj je 

statusni kod s kojim program zavr²ava. Kod 0 zna£i da program zavr- 

²ava na redovan na£in; ostali kodovi signaliziraju neku vrstu pogre²ke. 

Uobi£ajeno je npr. koristiti kod -1 ako se prekida zbog pogre²ke. 

• metoda getenv: dohva¢anje sistemskih varijabli (environment variables) 

• metoda arrayCopy: ekasno kopiranje sadrºaja iz jednog polja u drugo 

Detalje o ovim i drugim £lanovima klase treba potraºiti u dokumentaciji 

[1]. 

3.5 Klase-omota£i primitivnih vrsta, autoboxing 

Java razlikuje primitivne od referentnih vrsta podataka i stoga brojevi, 

logi£ke vrijednosti i znakovi nisu objekti. Mežutim, mnoga programska rje- 

²enja, kao npr. kolekcije podataka (vidjeti poglavlje 5), rade isklju£ivo s 

objektima. Da bi se ipak u takvim slu£ajevima moglo baratati i njima, 

u Javinu biblioteku klasa ugražene su posebne klase £ije instance predstavljaju 

podatke primitivnih vrsta. Radi se o sljede¢im klasama u paketu 

java.lang: 

1. Boolean 

2. Byte


3. Character 

4. Short 

5. Integer 

6. Long 

7. Float 

8. Double 

Jedna instanca predstavlja jednu vrijednost. Instance su nepromjenjive, 

²to dodatno olak²ava njihovo tretiranje kao da su podaci primitivne vrste 

(vidjeti odjeljak 3.3.2). Na primjer, ako negdje moramo koristiti objekte, 

a podatak kojim trebamo baratati je vrste int, moºemo koristiti omota£ 

Integer na sljede¢i na£in: 

int i = 1; 

Integer intObj = i; // omotavanje u objekt 

... radimo ne²to s omotanom vrijednosti ... 

int j = intObj; // razmotavanje natrag u primitivnu vrijednost 

Integer intObj2 = i + 1; 

int k = intObj + intObj2; 

Java dozvoljava implicitnu konverziju izmežu primitivnih vrijednosti i 

njihovih omota£a u izrazu dodjele vrijednosti. To jezi£no svojstvo naziva se 

autoboxing/unboxing. Dozvoljeno je i izvoditi ra£unske operacije nad omota£ima, 

kao ²to se vidi u posljednjem retku primjera. 

3.6 Konverzija izmežu podatka i njegovog znakovnog 

zapisa 

Klase omota£a primitivnih vrsta sadrºe i stati£ke metode koje parsiraju 

znakovne zapise vrijednosti. Primjeri: 

int i = Integer.parseInt( "-2" ); 

double d = Double.parseDouble( "2.021e-2" ); 

boolean b = Boolean.parseBoolean( "true" ); 


i = -2, d = 0.02021, b = true


Konverzija u suprotnom smjeru, iz primitivne vrijednosti u znakovni 

niz, moºe se obaviti na dva na£ina. Jedna je memorijski ekonomi£nija, ali 

druga ima elegantniji zapis: 

double d = 2.02; 

String s1 = String.valueOf( d ); 

String s2 = "" + d; 

U drugom retku koristi se stati£ka metoda String.valueOf. Metoda je 

preoptere¢ena i ima verziju za svaku primitivnu vrstu podataka. U tre¢em 

retku koristi se ve¢ prikazano svojstvo operacije ulan£avanja (u odjeljku 

3.3) da automatski pretvara sve primitivne podatke u nizove.

Poglavlje 4 

Iznimke 

U prakti£ki svakom programu dobar dio koda posve¢en je provjeri ispravnosti 

neke situacije i prijavljivanju pogre²aka ako se uo£i nepravilnost. Na 

primjer, tipi£no je provjeriti je li prosliježeni cijeli broj u potrebnom opsegu. 

U na²em slu£aju broja£a (ispis 2.13) bit ¢e potrebno npr. provjeriti 

da je ciklus brojanja prosliježen metodi setModulus pozitivan broj: 




{ 

private int modulus = 10; 

Ispis 4.1: ModuloCounter s provjerom parametra 


{ 


} 


{ 

} 


{ 

if ( newModulus < 0 ) 

System.out.println( "Negativan ciklus brojanja!" ); 

else 


} 


{ 

73

74 POGLAVLJE 4. IZNIMKE 

} 

} 

this.counterState = newState % this.modulus; 

Na prvi pogled ovo moºe izgledati kao savr²eno rje²enje ako je broj 

krivi, ispisuje se pogre²ka, ina£e se obavlja zatraºena akcija. Mežutim, u 

stvarnosti ovo je prili£no neupotrebljivo. Pozivaju¢a metoda uop¢e ne¢e 

imati informaciju o tome je li naredba za postavljanje ciklusa uspje²no izvr²ena. 

Program ¢e nastaviti dalje i, naravno, raditi neispravno. Programer, 

gledaju¢i ispis, mo¢i ¢e samo ustanoviti da je u jednom trenutku metoda 

setModulus pozvana s pogre²nom vrijedno²¢u. Tijekom izvr²avanja ta metoda 

se pozvala tko zna koliko puta i s kojih sve lokacija. 

Malo bolji pristup, koji se npr. koristi u jeziku C, je da metoda ne 

bude void, nego int i da broj koji vra¢a ovisi o uspje²nosti izvr²enja. Svaka 

pozivaju¢a metoda tada moºe provjeriti je li sve dobro zavr²ilo. Ovaj na£in 

opet ima niz mana npr. to zna£i da za svaki pojedini poziv bilo koje 

metode koja bi se mogla neuspje²no izvr²iti treba imati po jedan blok if 

za provjeru. Dodatni je problem ²to se sad povratna vrijednost ne moºe 

koristiti za regularne namjene mnoge metode nisu void pa da ih moºemo 

lako preurediti da vra¢aju int. 

4.1 Bacanje iznimke prijava iznimne situacije 

U jeziku Java za rje²avanje ovih problema postoji poseban mehanizam 

iznimke. Gornja metoda setModulus u Javi bi se izvela ovako: 


{ 

... 


{ 


throw new IllegalArgumentException( "Negativan ciklus brojanja" ); 

} 


... 

}

POGLAVLJE 4. IZNIMKE 75 

Primje¢ujemo klju£nu rije£ throw: njome se baca iznimku. Ovo je sasvim 

nov i neobi£an pojam i trebat ¢e malo vi²e vremena da legne po£etniku. 

Bacanjem iznimke prekida se izvr²avanje metode i ona, ako je i trebala 

vratiti neku povratnu vrijednost, u ovom slu£aju ne¢e ju vratiti, nego ¢e 

se u pozivaju¢oj metodi pojaviti ta ba£ena iznimka kao rezultat metode. 

Ako tamo nema nikakvog koda speci£nog za baratanje iznimkama, dogodit 

¢e se ne²to prili£no neo£ekivano: izvr²avanje te pozivaju¢e metode takožer 

¢e odmah biti prekinuto i ona ¢e ponovo baciti tu istu iznimku svojoj 

pozivaju¢oj metodi. Ako dakle imamo ovakav slu£aj: 


{ 

... 

Ispis 4.2: Bacanje i ponovno bacanje iznimke 


{ 



} 


} 

... 


{ 

private static boolean intermediateMethod( int i ) 

{ 

ModuloCounter mc = new ModuloCounter(); 

mc.setModulus( i ); 

System.out.println( "intermediateMethod uspje²no zavr²ava" ); 

return true; 

} 

} 


{ 

boolean b = intermediateMethod( -1 ); 

System.out.println( "intermediateMethod je vratila " + b ); 

} 

pokretanje programa rezultirat ¢e sljede¢im ispisom: 

Ispis 4.3: Izvje²taj o ba£enoj iznimci 

Exception in thread "main" java.lang.IllegalArgumentException: Negativan ciklus brojanja


at hr.fer.tel.jsem.AppThatUsesTheCounter.setModulus(AppThatUsesTheCounter.java:8) 

at hr.fer.tel.jsem.AppThatUsesTheCounter.intermediateMethod(AppThatUsesTheCounter.java:13) 

at hr.fer.tel.jsem.AppThatUsesTheCounter.main(AppThatUsesTheCounter.java:18) 

Primijetimo da se poruke intermediateMethod je vratila... i intermediateMethod 

uspje²no zavr²ava nisu ispisale. U intermediateMethod iznimka 

se pojavila u prvom retku i, u nedostatku koda koji ju obražuje, tu je metoda 

zavr²ila ponovnim bacanjem iste iznimke (eng. rethrow). Iznimka je 

tako stigla do metode main, takožer u njenom prvom retku. Budu¢i da od 

nje nema kamo dalje (to je metoda od koje je program zapo£eo), £itav 

program je prekinut uz prethodni ispis detaljnog izvje²taja o tome gdje 

je to£no do²lo do iznimke (cjelokupan redoslijed pozivanja metoda i to£no 

mjesto u kodu gdje se svaki poziv dogaža), koja je vrsta iznimke (Illegal- 

ArgumentException) i njen pobliºi opis (Negativan ciklus brojanja). Sve se 

to dogodilo automatski, bez ijednog retka koda vezanog uz obradu iznimke. 

Varijabli b u metodi main o£ito nije mogla biti dodijeljena nijedna vrijednost 

jer intermediateMethod nije zavr²ila vra¢anjem povratne vrijednosti. 

Iz toga je ve¢ jasno da se izvr²avanje ne moºe nastaviti normalnim putem 

jer je varijabla ostala neinicijalizirana, a ve¢ u sljede¢em retku se njena 

vrijednost treba ispisati. 

4.2 Hvatanje iznimke obrada iznimne situacije 

Prikazani na£in kori²tenja iznimke jo² uvijek nije previ²e svrsishodan jer ¢e 

uslijed svakog bacanja iznimke program pucati. U ve¢ini realnih situacija 

trebat ¢e se na odgovaraju¢i na£in pobrinuti za iznimnu situaciju i zatim 

nastaviti s izvr²avanjem programa. Klju£na je prednost ²to moºemo odabrati 

u kojoj metodi ¢emo napraviti provjeru to ne treba biti niti metoda 

gdje je do²lo do pogre²ke, niti metoda koja ju je izravno pozvala. Moºemo 

npr. sve iznimke obraživati u metodi main: 

Ispis 4.4: Hvatanje iznimke 


{ 

boolean b; 

try 

{ 

b = intermediateMethod( -1 );



} 

catch ( IllegalArgumentException e ) 

{ 

System.err.println( "Iznimka!"); 

e.printStackTrace(); 

} 

b = intermediateMethod( 1 ); 


"Drugi poku²aj: intermediateMethod je vratila " + b ); 

} 

Tu se pojavljuje nova konstrukcija, koja koristi i dvije nove klju£ne 

rije£i: try i catch. Pomo¢u try najavljuje se blok koda koji ¢e se poku²ati 

izvr²iti, ali u kojem bi moglo do¢i i do iznimke. 

U ovom trenutku potrebno je napomenuti par detalja u vezi s karakterom 

iznimke. U Javi to je jednostavno objekt kao i svaki drugi instanca 

klase java.lang.Exception ili bilo koje njene potklase. Iznimku se kreira na 

uobi£ajen na£in, operatorom new. Da je iznimka normalan objekt najjasnije 

se vidi po izjavi 

e.printStackTrace(); 

Tu smo pozvali metodu nad objektom iznimke. Ovo je vrlo korisna metoda 

jer ona ispisuje izvje²taj o iznimci, kao ²to je pokazano u ispisu 4.3. Ranije 

je prikazan primjer u kojem se izvje²taj ispisuje automatski, prije prekida 

programa. Ovom metodom moºemo eksplicitno zatraºiti takav izvje²taj, a 

bez prekidanja programa. Izvje²taj se ²alje na standardni izlaz za pogre²ke 

(System.err). 

Iznimku se hvata klju£nom rije£ju catch. ƒitava konstrukcija je catch 

( VrstaIznimke imeParametra ) i vrlo je srodna konstrukciji za deklaraciju 

parametra metode. Sama iznimka koja ¢e biti uhva¢ena moºe biti instanca 

navedene klase ili bilo koje potklase isto vrijedi i za parametar metode. 

Nakon ove konstrukcije slijedi blok koda u kojem se imeParametra moºe 

koristiti kao i svaka druga varijabla. U gornjem primjeru nad njom se poziva 

metoda getMessage, kojom raspolaºe svaka iznimka i vra¢a poruku koja joj 

je dodijeljena prilikom bacanja. 

Ako je iznimka uspje²no uhva¢ena u odgovaraju¢em bloku catch, ne¢e 

se dalje bacati. Nakon izvr²enja ovog bloka program dalje nastavlja normalno, 

izvr²avanjem koda koji slijedi nakon £itave konstrukcije try...catch. 

Ostatak koda nakon pojave iznimke pa do kraja bloka try ne¢e se izvr²iti 

a to je i bio cilj. U protivnom bismo se ponovo susreli s problemom ²to


u£initi npr. s neinicijaliziranom varijablom b. 

S druge strane, ako ba£ena iznimka nije one vrste koja se hvata catchom, 

pona²anje ¢e biti kao da tog bloka i nema iznimka ¢e se proslijediti 

dalje, pozivaju¢oj metodi. 

4.3 Zavr²ne radnje prije bacanja iznimke blok 

finally 

Blok try moºemo popratiti i posebnim blokom koda koji ¢e se sigurno 

izvr²iti, bez obzira je li do²lo do iznimke. To je prvenstveno korisno za 

slu£aj kad dože do iznimke jer u tom bloku imamo ²ansu obaviti neku 

zavr²nu radnju npr. tipi£an slu£aj je zatvaranje datoteka, internetskih 

konekcija i sl. prije nego ²to se metoda prekine bacanjem iznimke. Za to 

sluºi klju£na rije£ finally: 


{ 

... 

Ispis 4.5: Blok finally 

private void setModulus( int newModulus ) 

{ 



} 

} 

... 


{ 

private static boolean intermediateMethod( int i ) 

{ 

try 

{ 

ModuloCounter mc = new ModuloCounter(); 

mc.setModulus( i ); 

} 

finally 

{ 

System.out.println( "intermediateMethod zavr²ava" ); 

} 

return true; 

}


} 


{ 

boolean b; 

try 

{ 

b = intermediateMethod( -1 ); 


} 


{ 

System.out.println( "Iznimka: " + e.getMessage() ); 

} 

b = intermediateMethod( 1 ); 


"Drugi poku²aj: intermediateMethod je vratila " + b ); 

} 

O£ekivan ispis za ovaj, ve¢ dosta sloºen slu£aj je: 

intermediateMethod zavr²ava 

Iznimka: Negativan ciklus brojanja 

intermediateMethod zavr²ava 

Drugi poku²aj: intermediateMethod je vratila true 

Vidimo kako se sada tekst intermediateMethod zavr²ava ispisuje u 

oba slu£aja i kad je do²lo do iznimke, i kad nije. U gornjem primjeru blok 

finally kori²ten je samostalno, kao i blok catch u metodi main, ali op¢enito 

oni se mogu i kombinirati. Jedino treba po²tivati pravilo da finally dože 

na kraj, iza catch. 

U primjeru je kori²tena jo² jedna metoda denirana za sve iznimke 

getMessage. Ona vra¢a znakovni niz koji je prosliježen konstruktoru prilikom 

bacanja iznimke. 

4.4 Vi²estruki blokovi catch 

Jo² jedna prednost mehanizma iznimki je u tome ²to moºemo imati podulji 

blok koda u kojem se mogu pojavljivati raznorazne iznimke bez potrebe da 

se svaka obražuje tamo gdje se pojavila. Da bi ta prednost bila u potpunosti 

iskoristiva, mogu¢e je nakon bloka try imati ne jedan, nego proizvoljno 

mnogo blokova catch, svaki za svoju vrstu iznimke. Od svih njih izvr²it ¢e 

najvi²e jedan, i to prvi £ija vrsta parametra odgovara vrsti iznimke. Realisti£an 

primjer u kojem je potrebno hvatati razne iznimke bio bi prili£no 

kompleksan pa ¢emo ovdje dati samo shematski primjer:


Ispis 4.6: Vi²estruki blokovi catch 

public int someMethod() 

{ 

try 

{ 

method1(); 

method2(); 

method3(); 

return 0; 

} 


{ 

System.err.println( "Pogre²an argument" ); 

} 

catch ( NullPointerException e ) 

{ 

System.err.println( "Nul-referenca" ); 

} 

catch ( FileNotFoundException e ) 

{ 

System.err.println( "Datoteka ne postoji" ); 

} 

catch ( Exception e ) 

{ 

System.err.println( "Nepredvižena iznimka" ); 

} 

finally 

{ 

System.err.println( "Blok try zavr²ava" ); 

} 

return -1; 

} 

Uo£imo da se u posljednjem bloku catch hvata vrsta Exception. Taj blok 

je tu da uhvati bilo koju iznimku koju nije uhvatio nijedan prethodni blok. 

Vaºno je, naravno, da taj blok bude posljednji, u protivnom ¢e uvijek on 

hvatati iznimku. 

Potpuni redoslijed izvr²avanja je sljede¢i: prvo se normalno izvr²ava kod 

bloka try. Ako ne dože do iznimke, u posljednjem retku bloka try metoda 

treba uredno zavr²iti s povratnom vrijednosti 0. Mežutim, prije toga izvr- 

²ava se blok finally. Ako dože do iznimke, izvr²ava se odgovaraju¢i blok 

catch i nakon njega finally. U tom slu£aju nakon izvr²enja finally izvr²avanje 

nastavlja redovitim putem i nailazi se na return -1 pa metoda vra¢a 

vrijednost -1. Ako se pojavi iznimka koju se ne hvata, izvr²ava se blok 

finally i nakon toga metoda se prekida ponovnim bacanjem iste iznimke. 

Vidimo dakle da se blok finally izvr²ava apsolutno uvijek, bez obzira za-


vr²ava li blok try na redovan ili izniman na£in i bez obzira je li iznimka 

uhva¢ena ili nije. 

4.5 Najava iznimke; provjeravana i neprovjeravana 

iznimka 

Iznimke se u Javi dijele na dvije podvrste: provjeravane (eng. checked) i 

neprovjeravane (eng. unchecked). Sve neprovjeravane iznimke izvedene su iz 

RuntimeException; ostale su provjeravane. Sama RuntimeException je izravna 

potklasa spomenute klase Exception. 

Ako se moºe dogoditi da metoda baci provjeravanu iznimku, tada ju je 

potrebno najaviti klju£nom rije£ju throws: 

import java.io.*; 

... 

Ispis 4.7: Najava iznimke 

public static void fileMethod() 

throws FileNotFoundException 

{ 

File f = new File( "/hr/fer/tel/file1.txt" ); 

InputStream fis = new FileInputStream( f ); 

... 

} 

U primjeru se koriste Javine ugražene klase za baratanje datotekama 

(iz paketa java.io). U konstruktoru klase FileInputStream najavljeno je da 

bi mogao baciti provjeravanu iznimku FileNotFoundException (ako zatraºena 

datoteka ne postoji). Budu¢i da tu iznimka ne hvata, na²a metoda takožer 

mora najaviti da bi mogla baciti ovu iznimku, u protivnom ¢e prevoditelj 

prijaviti pogre²ku da metoda moºe baciti doti£nu iznimku, ali to ne 

najavljuje. 

Iz navedenoga je jasno zna£enje pridjeva provjeravana: za takvu iznimku 

kompilator provjerava moºe li do¢i do njenog bacanja i inzistira da 

to bude najavljeno. Na² primjeri£ni kod ne sadrºi eksplicitnu izjavu throw 

new FileNotFoundException(), ali kompilatoru je dovoljna £injenica da se koristi 

konstruktor koji tu iznimku najavljuje. Op¢enito, spomenuti konstruktor 

moºe biti izveden i tako da nikad ne baci iznimku, ali kompilatoru je 

dovoljna sama najava. Isto tako, svaka metoda koja poziva na²u metodu


fileMethod morat ¢e se pobrinuti za ovu iznimku £ak i ako izbacimo redak 

u kojem se koristi sporni konstruktor. 

Najavljena iznimka korisna je za slu£ajeve kad do nje moºe do¢i tijekom 

normalnog, ispravnog izvr²avanja programa. Na primjer, u na²em 

slu£aju programer ne moºe unaprijed znati ho¢e li potrebna datoteka postojati 

svaki put kad se program izvr²ava. To op¢enito i ne mora zna£iti 

da je do²lo do pogre²ke radi se jednostavno o izvanrednoj situaciji koju 

se zahvaljuju¢i mehanizmu iznimaka moºe obraživati na mjestu gdje je to 

najprakti£nije. Kori²tenjem provjeravane iznimke posti¢i ¢emo to da programer 

ne moºe zabunom zaboraviti zapisati kod koji obražuje tu uvijek 

prisutnu mogu¢nost. 

S druge strane, neprovjeravana iznimka koristi se za slu£ajeve u kojima 

se prijavljuje neispravnost situacija do koje u ispravnom programu jednostavno 

ne smije do¢i. Takav je na² raniji primjer s metodom setModulus 

ona je dizajnirana da prima pozitivan broj i nijedan smislen poziv ne 

moºe biti s negativnim brojem. Dakle, mora da se radi o programerskoj 

pogre²ci. Mogu¢nosti za ovakve pogre²ke vrebaju na svakom koraku i kod 

bi bio neprihvatljivo nepregledan kad bi se inzistiralo na najavi ili obradi 

svake mogu¢e takve iznimke. 

U praksi uvijek postoje i rubni slu£ajevi, gdje je nejasno koju vrstu 

iznimke koristiti. Java dozvoljava da se i neprovjeravane iznimke najavljuju 

kao pomo¢ programeru koji koristi takvu metodu, da bude spreman na 

mogu¢nost pojave doti£ne iznimke, iako nije duºan i²ta poduzeti. Najava 

neprovjeravane iznimke nema nikakvog utjecaja na kompilator iznimka i 

dalje ostaje neprovjeravana. 

4.5.1 Najava vi²e iznimki 

Metoda moºe najaviti proizvoljan broj iznimki. Navodi ih se redom, odvojene 

zarezom, npr. 

public void throwingMethod() 

throws FileNotFoundException, ClassNotFoundException, NamingException 

{ 

... 

}


4.6 Klasna hijerarhija iznimki 

Dosad je spomenuto nekoliko detalja o hijerarhiji klasa iznimki. Spomenuta 

je klasa Exception kao glavna klasa iz koje su izvedene druge iznimke. Mežutim, 

potpuna slika uklju£uje jo² nekoliko klasa. Prije svega tu je klasa 

Throwable, iz koje su izvedene to£no dvije klase: Error i Exception. Dakle, 

Throwable je u korijenu £itave klasne hijerarhije iznimki. Klasa Error i njene 

potklase rezervirane su za uporabu od strane Javinog virtualnog stroja i 

nisu namijenjene da ih se eksplicitno baca izjavom throw. Cjelokupna hijerarhija 

klasa £ije instance se mogu baciti prikazana je na slici 4.1. Dodatne 

klase iznimki koje uvode razvijatelji neizostavno moraju biti potklase od 

Exception. 

Throwable 

Error 

Exception 

pogreške koje 

signalizira JVM 

provjeravane 

iznimke 

RuntimeException 

neprovjeravane 

iznimke 

Slika 4.1: UML-ov dijagram klasa £ije instance se mogu baciti 

4.7 Kori²tenje ugraženih i vlastitih iznimki 

U Javinoj biblioteci postoji ve¢ mno²tvo iznimki, provjeravanih i neprovjeravanih. 

Nekoliko njih, neprovjeravanih, ima op¢enit karakter i u kodu ih 

treba koristiti gdje god zna£enje odgovara karakteru pogre²ke:


• NullPointerException baca se kad god se problem sastoji od toga da 

je neka referenca jednaka null umjesto da pokazuje na neki objekt. 

• IllegalArgumentException baca se kad se ustanovi da je metoda pozvana 

s pogre²nom vrijednosti nekog argumenta vrijednosti koja je 

protivna pravilima pozivanja doti£ne metode. U ovom poglavlju imali 

smo primjer pozivanja setModulus s negativnim brojem. 

• IllegalStateException baca se kad se neku metodu pozove dok je 

objekt u takvom stanju koje ne dopu²ta njezino pozivanje. Recimo da 

imamo klasu koja predstavlja broja£ koji odbroji do neke kona£ne vrijednosti 

i nakon toga ne moºe dalje, ve¢ se mora poni²titi. Ako u trenutku 

kad je broja£ ve¢ do²ao do gornje granice pozovemo increment, 

to bi bila situacija za bacanje ove iznimke. 

• ClassCastException baca se ako je metoda pozvana s instancom krive 

klase. To se dogaža tipi£no kad se radi o metodi koja je dio nekog 

su£elja pa formalno prima parametar op¢enitije vrste od one s kojom 

stvarno moºe raditi. 

• UnsupportedOperationException baca se ako je metoda pozvana nad 

objektom koji ju ne implementira. To se tipi£no dogaža kad objekt 

najavljuje da implementira neko su£elje, ali neka od metoda iz su£elja 

nije primjerena za takav objekt pa ju nema smisla implementirati. 

Za situacije speci£ne za softverski proizvod koji razvijamo treba denirati 

vlastitu klasu iznimke. Pravilo je da za £itav proizvod postoji samo 

jedna ili eventualno, za ve¢e projekte, nekoliko iznimki. Ako ih je vi²e, preporu£a 

se da sve budu izvedene iz jedne, op¢enite. Deniranje vlastite iznimke 

vrlo je jednostavno dovoljno je kreirati klasu izvedenu iz Exception 

za provjeravane odnosno RuntimeException za neprovjeravane iznimke. U 

klasi treba samo denirati konstruktore koji primaju iste parametre kao 

ve¢ postoje¢i konstruktori u natklasi i samo prosliježuju poziv na njih. 

Primjer: 

public class CounterException 

extends RuntimeException 

{ 

public CounterException() 

Ispis 4.8: Deniranje vlastite iznimke


{ 

} 

super(); 

} 

public CounterException( String message ) 

{ 

super( message ); 

} 

public CounterException( String message, Throwable cause ) 

{ 

super( message, cause ); 

} 

public CounterException( Throwable cause ) 

{ 

super( cause ); 

} 

Ovime je denirana neprovjeravana iznimka CounterException. Denirana 

su £etiri standardna konstruktora i sve ²to rade je da pozivaju isti takav 

konstruktor u natklasi.

Poglavlje 5 

Kolekcije objekata 

Jedna vrlo zna£ajna stvar u svakom programskom jeziku su kolekcije podataka. 

Kolekcija je jednostavno skupina objekata koju se moºe tretirati 

kao cjelinu. Osnovni primjeri su lista i skup, a Java podrºava jo² i repove. 

Struktura srodna kolekciji je i mapa (skup parova klju£-vrijednost). 

Jezik Java pruºa dobru podr²ku za kolekcije objekata. Kolekcije primitivnih 

podataka podrºane su neizravno putem posebnih objekata-omota£a 

primitivnih podataka. U biblioteci klasa, u paketu java.util, nalazi se pove¢i 

broj su£elja i klasa koje sa£injavaju sustav za manipulaciju kolekcija, 

tzv. Collections Framework. 

5.1 Su£elja Collection, List i Set 

Su£elje Collection jedno je od temeljnih su£elja u Collections Framework-u. 

Apstrahira mogu¢nosti zajedni£ke za sve kolekcije liste, skupove i repove. 

To su£elje je denirano ponajprije iz razloga koji je iznesen u odjeljku 1.7 

da putem varijable (parametra) ove vrste moºemo baratati bilo kojom kolekcijom 

u opsegu funkcionalnosti koji je zajedni£ki za sve njih. Uz kolekcije 

veºu se i dosad neprikazana jezi£na svojstva Jave tzv. generics. Pogledajmo 

metodu u kojoj se demonstrira nekoliko osnovnih tehnika baratanja 

kolekcijom: 

Ispis 5.1: Osnovno baratanje kolekcijom 

static void manipulateCollection( Collection col ) 

{ 

String msg = "Poruka"; 

boolean b = col.add( msg ); 

87

88 POGLAVLJE 5. KOLEKCIJE OBJEKATA 

if ( b ) 

System.out.println( "Poruka dodana u kolekciju" ); 

System.out.println( "Sadrºi li kolekcija poruku? " + 

col.contains( msg ) ); 

b = col.add( msg ); 

if ( b ) 

System.out.println( "Poruka dodana u kolekciju drugi put" ); 

System.out.println( "Broj elemenata u kolekciji: " + col.size() ); 

b = col.remove( msg ); 

if ( b ) 

System.out.println( "Poruka uklonjena iz kolekcije" ); 

System.out.println( "Sadrºi li kolekcija poruku? " + 

col.contains( msg ) ); 

} 

System.out.println( "Je li kolekcija prazna? " + col.isEmpty() ); 

Sintaksu vezanu uz generics vidimo u prvom retku, u deklaraciji parametra 

metode: Collection col. Time nazna£ujemo da kolekcija sadrºi 

instance klase String. Vrsta Collection je tzv. parametrizirana 

vrsta parametar je vrsta objekata koji se u njoj nalaze. Kôd demonstrira 

kori²tenje metoda su£elja Collection: add, contains, isEmpty, remove, size. 

Ispis ¢e se razlikovati ovisno o tome koja konkretna implementacija kolekcije 

se proslijedi metodi. Razlika ¢e prije svega biti izmežu lista i skupova. 

Napravimo ovakvu metodu main da to ispitamo: 

Ispis 5.2: Lista i skup 


{ 

List list1 = new ArrayList(); 

List list2 = new LinkedList(); 

} 

Set set1 = new HashSet(); 

Set set2 = new TreeSet(); 

System.out.println( "Poziv s ArrayList:" ); 

manipulateCollection( list1 ); 

System.out.println( "\nPoziv s LinkedList:" ); 

manipulateCollection( list2 ); 

System.out.println( "\nPoziv s HashSet:" ); 

manipulateCollection( set1 ); 

System.out.println( "\nPoziv s TreeSet:" ); 

manipulateCollection( set2 );

POGLAVLJE 5. KOLEKCIJE OBJEKATA 89 

Ovdje je uveden £itav niz novih vrsta podataka. List i Set su su£elja 

izvedena iz su£elja Collection. Svako od njih dodaje metode speci£ne za 

listu odnosno skup. ArrayList i LinkedList su konkretne klase koje implementiraju 

listu. U praksi se rutinski koristi ArrayList koja elemente liste 

drºi u polju (eng. array), a LinkedList samo iznimno, kad neko od svojstava 

ArrayList ne zadovoljava (npr. ako ¢e postojati velike oscilacije u 

broju pospremljenih elemenata). HashSet i TreeSet su konkretne klase koje 

implementiraju skup. Rutinski se koristi HashSet, na bazi he²-tablice. Ovo je 

jedan primjer klase koja ne¢e ispravno raditi ako ju koristimo s objektima 

koji nemaju ispravno izvedene metode equals i hashCode (vidjeti odjeljak 

3.2). TreeSet je speci£an po tome ²to sortira svoje elemente (implementira 

i posebno su£elje za sortirane skupove SortedSet). Da bi sortiranje bilo 

mogu¢e, objekti trebaju imati deniran prirodni poredak (vidjeti odjeljak 

5.6.1). Svi hijerarhijski odnosi spominjanih referentnih vrsta prikazani su 

na slici 5.1. 

Za ArrayList i LinkedList dobit ¢emo sljede¢i ispis: 

Poruka dodana u kolekciju 

Sadrºi li kolekcija poruku? true 

Poruka dodana u kolekciju drugi put 

Broj elemenata u kolekciji: 2 

Poruka uklonjena iz kolekcije 


Poruka uklonjena iz kolekcije drugi put 

Je li kolekcija prazna? true 

Za HashSet i TreeSet ispis ¢e izgledati druga£ije: 

Poruka dodana u kolekciju 


Broj elemenata u kolekciji: 1 

Poruka uklonjena iz kolekcije 

Sadrºi li kolekcija poruku? false 

Je li kolekcija prazna? true 

Primijetimo da poruka nije dodana/uklonjena po drugi put jer skup po 

deniciji sadrºi elemente bez ponavljanja. Dodatna osobina skupa je da ne 

zadrºava poredak kojim su elementi dodavani u njega (za razliku od liste). 

U metodi main kori²ten je udoma¢eni pristup da se za vrstu varijable 

uvijek koristi su£elje tipi£no List ili Set, ovisno o namjeni a nikada 

konkretne vrste ArrayList ili HashSet. Same klase ne deniraju gotovo nijednu 

dodatnu metodu i gotovo nikad nema razloga koristiti ih za vrstu 

varijable (ili parametra, atributa itd.). Njihovim kori²tenjem samo onemogu¢ujemo 

kasniji jednostavan prelazak na druga£iju implementaciju.


«interface» 

Collection 

«interface» 

SortedSet 

«interface» 

Set 

«interface» 

List 

TreeSet 

HashSet 

ArrayList 

LinkedList 

Slika 5.1: UML-ov dijagram klasa za Collection-Framework 

5.2 Prelazak preko svih £lanova kolekcije 

Naj£e²¢i na£in kori²tenja kolekcije je da se priježe po svakom njenom £lanu, 

jedan po jedan, i obavi neki posao. Za to postoji posebna jezi£na konstrukcija, 

tzv. petlja enhanced for 1 : 

Ispis 5.3: Prolaz po kolekciji petljom enhanced for 

static void iterateOverCollection( Collection col ) 

{ 

for ( String s : col ) 

System.out.println( "ƒlan kolekcije: " + s ); 

} 


{ 

List list = new ArrayList(); 

list.add( "a" ); 

list.add( "b" ); 

list.add( "c" ); 

iterateOverCollection( list ); 

} 

U metodi iterateOverCollection demonstrirana je konstrukcija enhanced 

for. Izraz u zagradama prije dvoto£ke je deklaracija varijable koja ¢e u 

svakom koraku petlje sadrºati po jedan element kolekcije. ƒlan iza dvoto£ke 

je kolekcija po kojoj treba obaviti prelazak. 

1 U praksi se jo² koriste i izrazi for each i for/in


Ako metodu main prepravimo da koristi HashSet, mo¢i ¢emo uo£iti da se 

po elementima ne prolazi u istom poretku u kojem smo ih dodavali: 


{ 

Set set = new HashSet(); 

set.add( "a" ); 

set.add( "b" ); 

set.add( "c" ); 

iterateOverCollection( set ); 

} 

Ispis: 

ƒlan kolekcije: a 

ƒlan kolekcije: c 

ƒlan kolekcije: b 

5.3 Kolekcije i primitivne vrste podataka 

Podaci primitivne vrste ne mogu se spremati u kolekcije pa se koriste 

objekti-omota£i podataka primitivnih vrsta. Jezi£no svojstvo autoboxing/unboxing 

dozvoljava sintasku po kojoj izgleda kao da se spremaju sami podaci primitivne 

vrste. Primjer: 

Ispis 5.4: Kolekcija i primitivne vrste podataka 


{ 

List intList = new ArrayList(); 

intList.add( 2 ); 



if ( intList.contains( 3 ) ) 

System.out.println( "Lista sadrºi broj 3" ); 

for ( int i : intList ) 

System.out.println( "ƒlan liste: " + i ); 

} 

List boolList = new ArrayList(); 

boolList.add( true ); 

boolList.add( 2 == 3 ); 

List charList = new ArrayList(); 

charList.add( 'a' ); 

charList.add( 'b' ); 

char c = charList.get( 0 ); // dohva¢a prvi element liste


5.4 Napredni prelazak po £lanovima kolekcije 

Konstrukcija enhanced for prikazana u odjeljku 5.2 kra¢i je zapis za ovakav 

kod, koji se implicitno generira prilikom prevoženja te konstrukcije i koristi 

poznatu sintaksu petlje for: 

Ispis 5.5: Prolaz po kolekciji eksplicitnim kori²tenjem iteratora 

static void iterateOverCollection( Collection col ) 

{ 

for ( Iterator iter = col.iterator(); iter.hasNext(); ) 

{ 

String s = iter.next(); 

System.out.println( "ƒlan kolekcije: " + s ); 

} 

} 

(u realnom slu£aju ne koristi se ime varijable iter, koje bi tada bilo rezervirano, 

nego neko ime koje se ne moºe normalno pojaviti u kodu.) 

Za neke speci£ne namjene potrebno je koristiti upravo ovakvu sintaksu 

jer nam je tako eksplicitno dostupan poseban objekt iterator po kolekciji. 

Njega moºemo zamisliti kao pokaziva£ na trenutni objekt u kolekciji. 

Preusmjerujemo ga na sljede¢i element pozivom metode next, £ija povratna 

vrijednost je taj sljede¢i element. Prije prvog poziva te metode iterator jo² 

ne pokazuje ni na jedan element, tako da se prvim pozivom dobiva prvi 

element. 

Jedna od dodatnih mogu¢nosti je metoda remove kojom se trenutni 

objekt uklanja iz kolekcije: 

Ispis 5.6: Kori²tenje iteratora za mijenjanje liste 


{ 

List intList = new ArrayList(); 




} 

for ( Iterator iter = intList.iterator(); iter.hasNext(); ) 

{ 

int i = iter.next(); 

if ( i == 3 ) 

iter.remove(); 

} 

for ( int i : intList ) 

System.out.println( "ƒlan kolekcije: " + i );


Postoje i druge mogu¢nosti, o kojima se moºe informirati u dokumentaciji 

[1]. Za prolazak po listama postoji i specijalizirani ListIterator koji 

nudi jo² vi²e mogu¢nosti, speci£nih za liste. 

5.5 Mapa 

Pojam mapa odnosi se na skup preslikavanja izmežu nekih podataka (vrijednosti) 

i s njim povezanih identikacijskih podataka (njihovih klju£eva). 

Na primjer, ve¢ina baza podataka koje sadrºe podatke o drºavljanima RH 

kao klju£ koriste JMBG jer je to kratak podatak jedinstven za svakog gražana. 

Klju£ je dakle ²to kra¢i podatak na osnovu kojega se moºe nedvosmisleno 

identicirati neki ve¢i slog podataka. 

Mapa je korisna struktura podataka za velik broj namjena, npr. kad 

god imamo zbirku objekata koje je potrebno dohva¢ati po imenu ili nekom 

drugom ID-ju. U Javi je za mape denirano su£elje Map. Ovaj primjer 

demonstrira njegovu uporabu: 

Ispis 5.7: Klasa Student koja demonstrira mapu 

public class Student 

{ 

private String id; 

private String firstName; 

private String lastName; 

public Student( String id, String firstName, String lastName ) 

{ 

this.id = id; 

this.firstName = firstName; 

this.lastName = lastName; 

} 

... metode getId, getFirstName, getLastName ... 

public String toString() 

{ 

return this.firstName + " " + this.lastName; 

} 


{ 

Student stud1 = new Student( "id1", "Bill", "McGill" ); 

Student stud2 = new Student( "id2", "John", "Pepper" ); 

Map students = new HashMap(); 

students.put( stud1.id, stud1 );


students.put( stud2.id, stud2 ); 

} 

} 

Student fetchedStudent = students.get( "id2" ); 

System.out.println( "Dohva¢eni student: " + fetchedStudent ); 

Denirana je mala klasa koja sadrºi podatke o studentu. Instance te 

klase spremaju se u mapu tako da se kao klju£ koristi atribut id. Op¢enito 

nije nuºno da klju£ bude dio objekta, ali je uobi£ajeno. I za klju£ i 

za vrijednost moºe se koristiti bilo koji objekt, bilo koje vrste. Vrsta Map je 

parametrizirana s dva parametra prvi je vrsta klju£a, a drugi vrsta vrijednosti. 

Isto se, naravno, odnosi i na HashMap. Ovo je, ina£e, jo² jedna klasa 

koja se oslanja na ispravno funkcioniranje metoda equals i hashCode u objektima 

koji se koriste kao klju£. Klasa String ima uredno implementirane ove 

metode pa ne¢e biti problema. 

Iz primjera mogu se i²£itati dvije najvaºnije metode su£elja Map: put( 

key, value ) i get( key ). Za ostale raspoloºive metode treba konzultirati 

dokumentaciju [1]. 

5.6 ƒesto kori²teni algoritmi nad kolekcijama 

U paketu java.util postoji klasa Collections koja ne sluºi za instanciranje, 

ve¢ sadrºi pove¢i broj stati£kih metoda koje provode £esto kori²tene 

algoritme za obradu kolekcija. Postoje npr. shuffle, reverse, sort, min, max 

itd. Za ove algoritme kaºe se da su polimorfni jer, sluºe¢i se Javinim polimorzmom, 

mogu raditi s velikim brojem razli£itih vrsta kolekcija. Za 

mnoge algoritme (prije svega sort) potrebno je da elementi kolekcije budu 

usporedivi, ²to tehni£ki zna£i da moraju ispravno implementirati su£elje 

Comparable. 

5.6.1 Implementiranje su£elja java.lang.Comparable 

Su£elje Comparable je parametrizirano parametar je neka vrsta T. U 

na£elu se kao parametar navodi upravo klasa u kojoj implementiramo to 

su£elje. Time kaºemo kompilatoru da se objekte na²e klase moºe usporeživati 

samo s drugim objektima iste klase. Op¢enito, tu bi se mogla staviti 

bilo koja klasa, ali druge vrijednosti ne¢e imati smisla osim eventualno


neke natklase trenutne klase, u slu£aju da imamo vi²e sli£nih klasa £ije 

instance se mogu mežusobno usporeživati. 

Ovo su£elje sadrºi samo jednu metodu: compareTo( T ). Povratna vrijednost 

je int koji mora biti nula za jednake objekte, negativan ako je 

trenutni objekt manji od prosliježenog i pozitivan ako je trenutni objekt 

ve¢i od prosliježenog. Zna£enje pojmova manji odnosno ve¢i ovisi o 

vrsti objekta. Poredak objekata u kojem se nijedan objekt ne pojavljuje 

prije nekog drugog koji je od njega manji naziva se prirodnim poretkom 

tih objekata. Metoda compareTo, dakle, odrežuje prirodni poredak instanci 

klase u kojoj je implementirana. Na primjer, u klasi Student iz ispisa 5.7 

mogli bismo tu metodu implementirati ovako: 

public class Student 

implements Comparable 

{ 

... isti kod kao ranije ... 

} 

Ispis 5.8: Metoda compareTo 

public int compareTo( Student that ) 

{ 

return this.lastName.compareTo( that.lastName ); 

} 

Klasa sad najavljuje da implementira su£elje Comparable. Metoda compareTo, 

oslanjaju¢i se na String-ovu implementaciju iste metode, usporežuje studente 

po prezimenu. 

5.6.2 Poredak razli£it od prirodnog su£elje 

java.util.Comparator 

Sve metode u klasi Collections koje se oslanjaju na prirodni poredak objekata 

imaju i verzije koje se oslanjaju na poseban objekt-komparator, koji 

moºe nametnuti proizvoljan poredak nad objektima. Takav objekt mora 

implementirati su£elje java.util.Comparator. Evo primjera komparatora 

za studente koji name¢e poredak po ID-ju: 

Ispis 5.9: Komparator za studente koji name¢e poredak po ID-ju 

public class StudentComparatorById 

implements java.util.Comparator 

{


} 

public int compare( Student left, Student right ) 

{ 

return left.getId().compareTo( right.getId() ); 

} 

5.6.3 Primjer kori²tenja metode Collections.sort 


{ 

List students = Arrays.asList( new Student[] 

{ 

new Student( "005", "Joshua", "Bloch" ), 

new Student( "003", "Paul", "Graham" ), 

new Student( "004", "Richard", "Dawkins" ), 

new Student( "002", "Rick", "Martinoff" ), 

} 

); 

} 

System.out.println( "Po£etni popis:" ); 

for ( Student student : students ) 

System.out.println( student ); 

Collections.sort( students ); 

System.out.println( "\nStudenti sortirani po prezimenu:" ); 



Collections.sort( students, new StudentComparatorById() ); 

System.out.println( "\nStudenti sortirani po ID-ju:" ); 




Po£etni popis: 

005 Joshua Bloch 

003 Paul Graham 

004 Richard Dawkins 

002 Rick Martinoff 

Studenti sortirani po prezimenu: 

005 Joshua Bloch 

004 Richard Dawkins 



Studenti sortirani po ID-ju: 



004 Richard Dawkins


005 Joshua Bloch

Poglavlje 6 

Polja 

Polje je blok u memoriji u koji je spremljen niz podataka iste vrste. U 

Javi polje je izvedeno kao objekt, ali posebnog karaktera. Polja su objekti 

posebne referentne vrste polja i njima se barata putem referenci, kao i 

ostalim objektima. Ovo treba uvijek imati na umu jer vrijedi sve re£eno za 

referentne varijable u odjeljku 2.1.2. 

Sva polja u osnovi su jednodimenzionalna. Dvodimenzionalno polje izvedeno 

je kao jednodimenzionalno polje referenci na druga jednodimenzionalna 

polja. 

6.1 Osnovni elementi sintakse 

Jednodimenzionalna polja: 

Ispis 6.1: Rad s jednodimenzionalim poljem 

int[] intArray; // deklaracija varijable polja 

intArray = new int[3]; // kreiranje praznog polja (popunjeno nulama) 

int i = intArray[0]; // pristup £lanu polja 

intArray = { 1, 2, 3 }; // kreiranje uz popunu 

// navedenim vrijednostima 

Uo£imo sintaksu u posljednjem retku: na desnoj strani ne treba koristiti 

operator new i to£nu vrstu podataka, dovoljan je samo doslovan popis £lanova. 

Java ¢e automatski stvoriti polje one vrste koja je deklarirana na 

lijevoj strani. 

ƒlanovi polja inicijaliziraju se po istim pravilima kao i atributi objekta 

brojevi na nulu, logi£ke vrijednosti na false, a reference na null. 

Dvodimenzionalna polja (analogno i za vi²edimenzionalna): 

99

100 POGLAVLJE 6. POLJA 

Ispis 6.2: Rad s dvodimenzionalnim poljem 

int[][] intArray; 

intArray = new int[2][3]; 

int i = intArray[0][0]; 

intArray = { {1, 2}, {3, 4}, {5, 6} }; 

Petlja enhanced for za prolaz po svim £lanovima polja: 

Ispis 6.3: Prolaz po svim £lanovima polja petljom enhanced for 


{ 

int[] intArray = { 1, 2, 3, 4, 5 }; 

for ( int i : intArray ) 

System.out.print( " " + i ); 

} 

System.out.println(); 

Dvodimenzionalno polje ne mora nuºno biti pravokutno, ²to slijedi iz 

re£enog da je to ustvari polje polja. Sljede¢i primjer demonstrira ovo: 

Ispis 6.4: Trokutasto dvodimenzionalno polje 


{ 

int[][] int2Array = { {11}, {21, 22}, {31, 32, 33} }; 

for ( int[] intArray : int2Array ) 

{ 

for ( int i : intArray ) 

System.out.print( " " + i ); 

} 

} 

System.out.println(); 

U prvom retku koda kreira se polje polja tako da je njegov prvi £lan polje 

duljine jedan, drugi £lan polje duljine dva i tre¢i £lan polje duljine tri. 

Zatim slijedi dvostruka petlja u kojoj se ispisuje cjelokupan sadrºaj stvorene 

strukture. Time se vizualizira trokutasti izgled strukture. Ispis je ovakav: 

11 

21 22 

31 32 33 

Polja mogu sadrºavati i reference na objekte. U deklaraciji se navodi 

referentna vrsta, npr. String[] stringArray.

POGLAVLJE 6. POLJA 101 

6.2 Polje kao objekt 

Polje, iako nije u pravom smislu instanca neke klase, svejedno je objekt 

koji je instanceof java.lang.Object, pa raspolaºe i svim odgovaraju¢im metodama. 

Svako polje ima i cjelobrojni atribut length, jednak njegovom kapacitetu. 

Atribut je final jer se kapacitet polja ne moºe naknadno mijenjati. 

Koristi ga se npr. za sloºenije primjere prolaska po svim £lanovima polja: 

Ispis 6.5: Prolaz po polju kori²tenjem eksplicitnog indeksa 

int[] intArray = new int[3]; 

for ( int i = 0; i < intArray.length; i++ ) 

{ 

int j = intArray[i]; 

... 

} 

6.3 Interakcija s kolekcijama 

Kolekcije su eksibilnije i op¢enito korisnije strukture od polja. Mežutim, 

polja su siroviji oblik strukture i stoga ra£unski i memorijski ekasnija. 

Prednost je i ²to se za rad s poljima moºe koristiti elegantnija sintaksa. 

Javina biblioteka podrºava laku transformaciju izmežu kolekcija i polja: 

Ispis 6.6: Pretvorbe izmežu polja i liste 

String[] stringArray = { "Harry", "Moe", "Joe" }; 

// konverzija polja u listu: 

List stringList = Arrays.asList( stringArray ); 

// konverzija liste u polje: 

String[] stringArray2 = stringList.toArray( new String[0] ); 

Metodi toArray mora se proslijediti makar prazno polje jer je potrebna informacija 

o tome koju vrstu polja treba stvoriti. Ovdje, naºalost ne pomaºu 

generics i to se ne dogaža automatski. Ako je prosliježeno polje dovoljno 

veliko, iskoristit ¢e se; u protivnom se stvara novo. 

Metoda asList moºe se iskoristiti i za jednostavno stvaranje liste popunjene 

doslovno navedenim vrijednostima: 

List stringList = Arrays.asList( "Harry", "Moe", "Joe" ); 

Dobivena lista ima ksiran sadrºaj zabranjeno je pozivati metode add, 

remove i ostale koje bi ga mijenjale.

Poglavlje 7 

Komunikacija s okolinom 

Svaka aplikacija treba komunicirati s okolinom. To se prije svega odnosi na 

korisni£ko su£elje (tipkovnica i zaslon), sustav datoteka i ra£unalsku mreºu. 

Ovdje se prikazuje na koji na£in se u jeziku Java komunicira s okolinom. 

7.1 Tokovi podataka 

Osnovna paradigma koja se u Javi koristi za razmjenu podataka s okolinom 

je tok podataka (eng. data stream). Postoje ulazni i izlazni tokovi i predstavljeni 

su apstraktnim klasama InputStream odnosno OutputStream. Nalaze 

se u paketu posve¢enom komunikaciji, java.io. Za svaku vrstu resursa s kojim 

se moºe komunicirati (zaslon, datoteka, udaljeno ra£unalo itd.) postoje 

konkretne klase izvedene iz njih. Apstraktne klase deklariraju osnovne metode 

za rad s tokom available, read, reset i close za InputStream odnosno 

write, flush i close za OutputStream. Sljede¢i primjer demonstrira kori²tenje 

izlaznog toka: 

Ispis 7.1: Rad s izlaznim tokom 

import java.io.OutputStream; 

import java.io.IOException; 

... 

static void sendToOutput( OutputStream os ) 

throws IOException 

{ 

for ( int i = 0; i < 256; i++ ) 

os.write( i ); 

os.flush(); 

103

104 POGLAVLJE 7. KOMUNIKACIJA S OKOLINOM 

... daljnje operacije nad tokom ... 

} 

os.close(); 

Ova metoda moºe raditi s bilo kakvim izlaznim tokom. U nju ¢e zapisati 

niz okteta od nule do 255 i nakon toga ju zatvoriti. Metoda flush poziva se 

kad se ºeli osigurati da podaci budu odmah isporu£eni na odredi²te. U protivnom 

¢e se najvjerojatnije gomilati u mežuspremniku u radnoj memoriji 

dok ih se ne skupi dovoljno za masovno slanje. Kori²tenje mežuspremnika 

op¢enito zna£ajno podiºe ekasnost komunikacije jer se ²alju ve¢i blokovi 

podataka, tako da flush ne treba koristiti ako to nije zaista potrebno. 

Ovaj primjer demonstrira kori²tenje ulaznog toka: 

Ispis 7.2: Rad s ulaznim tokom 

import java.io.InputStream; 


... 

static void receiveInput( InputStream is ) 


{ 

while ( true ) 

{ 

int i = is.read(); 

if ( i == -1 ) 

break; 

System.out.println( i ); 

} 

is.close(); 

} 

Metoda read vra¢a pro£itani oktet. Ako vrati vrijednost -1, to zna£i da je 

tok do²ao do kraja. Op¢enito se ne moºe samo ispitati je li tok do²ao do 

kraja bez poku²aja £itanja pa ne postoji posebna metoda za to koju bi se 

moglo koristiti u uvjetu petlje while. Metoda available vra¢a broj okteta 

raspoloºivih odmah, bez £ekanja. Ako vrati nulu, to ne mora zna£iti da je 

tok do²ao do kraja, ve¢ samo da trenutno nema novih podataka. 

7.2 Pisa£i i £ita£i 

Za komunikaciju tekstualnim podacima postoje posebni omota£i sirovih 

tokova okteta koji ih pretvaraju u tokove znakova. U Javinoj terminologiji

POGLAVLJE 7. KOMUNIKACIJA S OKOLINOM 105 

to su pisa£i (osnovna klasa Writer) i £ita£i (osnovna klasa Reader). Koriste 

se sli£no kao sirove tokove, ali barataju podacima vrste char. Jo² je 

prakti£nije koristiti klase s ugraženim mežuspremnikom (BufferedReader i 

PrintWriter) koje omogu¢uju komunikaciju redak po redak umjesto znak 

po znak. Ovo je prikazano u primjerima: 

Ispis 7.3: Pisa£ i £ita£ 

import java.io.Writer; 

import java.io.PrintWriter; 

import java.io.Reader; 

import java.io.BufferedReader; 


... 

static void writeOutput( Writer writer ) 


{ 

PrintWriter pw = new PrintWriter( writer ); 

pw.println( "Prvi redak" ); 

pw.println( "Drugi redak" ); 

pw.flush(); 

pw.close(); 

} 

static void readInput( Reader reader ) 


{ 

BufferedReader br = new BufferedReader( reader ); 

while ( true ) 

{ 

String line = br.readLine(); 

if ( line == null || line.length() == 0 ) 

break; 

System.out.println( line ); 

} 

br.close(); 

} 

Metoda readInput zavr²it ¢e ako naiže na kraj ulaznog toka (line == null) 

ili ako pro£ita prazan redak (line.length() == 0). 

Pisa£ i £ita£ rade tako da se povezuju sa sirovim tokom okteta i obavljaju 

potrebne konverzije. Povezuje ih se pri instanciranju proslježivanjem 

objekta toka konstruktoru. Sljede¢i primjer prikazuje metode koje pozivaju 

metode iz ispisa 7.3 s odgovaraju¢e omotanim sirovim tokovima: 


Ispis 7.4: Omota£i podatkovnih tokova

106 POGLAVLJE 7. KOMUNIKACIJA S OKOLINOM 

import java.io.OutputStreamWriter; 

import java.io.InputStream; 

import java.io.InputStreamReader; 


... 

static void writeOutput( OutputStream os ) 


{ 

writeOutput( new OutputStreamWriter( os ) ); 

} 

static void readInput( InputStream is ) 


{ 

readInput( new InputStreamReader( is ) ); 

} 

7.3 Komunikacija s korisnikom 

Osnovna tekstualna komunikacija s korisnikom ostvaruje se putem standardnog 

ulaz/izlaza koji pruºa svaka ra£unalska platforma. U Javi se s 

njima povezuje putem stati£kih atributa u klasi System. Ispis na standardni 

izlaz sreli smo ve¢ mnogo puta u kodu, svaki put kad se koristio izraz 

System.out.println( ... ). Stati£ki atribut out sadrºi referencu na objekt 

vrste PrintStream, koja je vrlo srodna prikazanoj vrsti PrintWriter i denira 

mnoge identi£ne metode. Za prakti£no kori²tenje standardnog ulaza 

potrebno je eksplicitno dodati omota£e, kao u ispisu 7.4. Kod iz ispisa 7.3 

i 7.4 moºemo isprobati dodavanjem sljede¢e metode main: 


... 



{ 

System.out.println( "Utipkaj ne²to!" ); 

readInput( System.in ); 

} 

U konzolu treba utipkati tekst i pritisnuti Enter. Program ¢e ponoviti 

utipkano. Program dovr²avamo utipkavanjem praznog retka. Atribut 

System.in je vrste InputStream pa ¢e se pozvati metoda readInput( InputStream 

) iz ispisa 7.4, koja ¢e onda proslijediti poziv metodi readInput( BufferedReader 

) iz ispisa 7.3.

POGLAVLJE 7. KOMUNIKACIJA S OKOLINOM 107 

7.4 Rad s datotekama 

Datotekama se u Javi barata putem objekata vrste File. To su tzv. handleobjekti 

jer postojanje objekta ne zna£i da postoji i datoteka koju on predstavlja. 

Objektu se zada putanja do datoteke i zatim ga se moºe pitati postoji 

li datoteka, je li u pitanju prava datoteka ili kazalo itd. Ako datoteka 

ne postoji, moºe ju se stvoriti. Sljede¢i kod demonstrira rad s datotekama. 

I on se oslanja na metode iz ispisa 7.3 i 7.4. 


import java.io.FileOutputStream; 

import java.io.FileInputStream; 

import java.io.File; 

... 



{ 

File file = new File( "Text.txt" ); 

file.createNewFile(); 

System.out.println( "Zapisujem u datoteku..." ); 

writeOutput( new FileOutputStream( file ) ); 

System.out.println( "ƒitam iz datoteke..." ); 

readInput( new FileInputStream( file ) ); 

} 

Moºemo vidjeti da se datoteku otvara za pisanje instanciranjem klase 

FileOutputStream kojoj se proslježuje instanca klase File. ƒim se taj objekt 

kreira, datoteka je ve¢ otvorena i spremna za zapisivanje. Analogno se i 

£ita iz datoteke. 

7.5 Rad s internetskim konekcijama 

Za dohvat sadrºaja s nekog URL-a dovoljna su samo dva retka koda (uz 

ve¢ postoje¢i kod iz ispisa (7.3 i 7.4): 

java.net.URL url = new java.net.URL( "http://www.google.com" ); 

readInput( url.openStream() ); 

Klasa URL predstavlja lokaciju na Internetu identiciranu URL-om (uniform 

resource locator). Pozivom metode openStream automatski se obavljaju 

sve radnje potrebne za pristup resursu pod tim URL-om kontaktira se 

DNS, otvara mreºna konekcija na potrebnom portu, ²alje HTTP-ov zahtjev 

za dostavom resursa i kreira objekt toka podataka koji ¢e isporu£ivati 

podatke koje posluºitelj ²alje kao odgovor.

Poglavlje 8 

Uzorci u dizajnu koda 

U praksi, pri izradi programskih rje²enja mnoge vrste problema koje treba 

rje²avati opetovano se pojavljuju bez obzira na konkretni zadatak. S vremenom 

su sazrijela za svaki takav tipi£an problem najbolja rje²enja, koja 

pokrivaju sve suptilnije nijanse problema 1 . Razvijatelj si moºe drasti£no 

olak²ati ºivot ako prou£i ta rje²enja tako da ih moºe primijeniti kad zatreba. 

Takožer, baratanje vokabularom vezanim uz uzorke (prije svega prepoznavanje 

uzoraka po imenu) bitno olak²ava komunikaciju izmežu razvijatelja, 

koji tako mogu puno ekasnije raspravljati o svojim programskim rje²enjima. 

Ideja uzoraka u dizajnu koda doºivjela je najve¢i proboj 1995. godine, 

kad je objavljena kultna knjiga Design Patterns [3] £etvorice autora popularno 

zvanih The Gang of Four ili GoF, kako se naj£e²¢e oslovljava i 

samu knjigu. U ovom poglavlju bit ¢e kao primjer ove koncepcije prikazano 

nekoliko najjednostavnijih uzoraka: Template method, Observer, Adapter i 

Decorator. 

8.1 Template method 

Ovaj uzorak jednostavan je za razumjeti i ima vrlo ²iroku primjenu. Ustvari, 

primijenili smo ga jo² u prvom poglavlju, prilikom refaktorizacije u 

odjeljku 1.11. Drugo ime za Template method je polimorfna metoda. Sli£an 

izraz, polimorfni algoritam, spominjao se ve¢ u poglavlju o kolekcijama, u 

odjeljku 5.6. Dakle, radi se naprosto o metodi koja u svojem kodu sadrºi 

1 U ovoj skripti se, mežutim, ne¢e ulaziti u te nijanse. Ovdje se daje samo najosnovniji 

uvod u koncepciju uzoraka. 

109

110 POGLAVLJE 8. UZORCI U DIZAJNU KODA 

pozive metoda koje podlijeºu polimorzmu odnosno dinami£kom povezivanju. 

Metoda na apstraktnoj razini implementira neki algoritam, gdje se 

pojedini koraci deniraju samo na razini ²to a ne i kako. U prvom poglavlju 

imali smo sljede¢i trivijalan primjer polimorfne metode: 



{ 

... 


{ 

setState( getState() + 1 ); 

} 

} 


Metoda increment je polimorfna jer se oslanja na apstraktnu metodu 

setState. Dakle, odrežuje da se mora postaviti novo stanje, ali ne propisuje 

to£no kako se postavlja novo stanje. To ¢e ovisiti o konkretnoj implementaciji 

metode setState. U na²em primjeru imali smo dvije varijante 

te metode: u klasi SimpleCounter jednostavno se prosliježeni int zapisao u 

atribut, dok se u klasi ModuloCounter zapisao ostatak dijeljenja s modulom. 

8.2 Observer 

Recimo da razvijamo softver za simulaciju rada mreºe TCP/IP. Svaki komunikacijski 

£vor moºe primiti neki paket namijenjen bilo njemu, bilo nekom 

daljnjem £voru i treba ga u skladu s time proslijediti dalje ili konzumirati. 

šelimo da na²em objektu koji predstavlja komunikacijski £vor 

moºemo dodavati procedure za obradu dogažaja paket stigao u £vor X. 

Na primjer, u najjednostavnijem slu£aju trebat ¢e ispisati tekstualnu poruku 

na standardni izlaz. U malo naprednijem slu£aju trebat ¢e prikazati 

poruku u prozoru gra£kog su£elja. Za o£ekivati je i da ¢emo imati gra£ki 

prikaz mreºe na kojem treba vizualizirati putovanje paketa od £vora do 

£vora. U tom slu£aju bit ¢e potrebno kad paket stigne u £vor promijeniti 

neki detalj u prikazu, npr. boju £vora. Sve te mogu¢nosti ºelimo imati na 

raspolaganju kao korisnik klase koja predstavlja mreºu TCP/IP, ²to zna£i 

bez ikakvih intervencija u izvorni kod te klase dapa£e, bez posjedovanja

POGLAVLJE 8. UZORCI U DIZAJNU KODA 111 

njenog izvornog koda. O£ito je da ¢e klasa £vora morati imati ugraženu 

podr²ku za to. Ta podr²ka ugražuje se kori²tenjem uzorka Observer. 

Prvo ²to treba uvesti je objekt-oslu²kiva£ (to je observer, ali u kontekstu 

Jave uobi£ajen je izraz listener). On ima metodu koju ¢e objekt £vora 

pozvati i time signalizirati stigao je paket. Oslu²kiva£a kreiramo i prijavimo 

£voru pozivanjem £vorove metode npr. addReceiveListener. Svaki 

put kad primi paket, £vor mora pro¢i po listi svih prijavljenih oslu²kiva£a 

i pozvati njihovu metodu npr. packetReceived. U toj metodi nalazi se kod 

koji obražuje dogažaj primitka paketa. 

Za oslu²kiva£a prvo treba denirati su£elje, ReceiveListener. Njega onda 

mogu implementirati razli£ite verzije oslu²kiva£a. 

Ispis 8.5: Su£elje oslu²kiva£a dolaznih paketa 

package hr.fer.tel.jsem.observer; 

public interface ReceiveListener 

{ 

void packetReceived( Packet packet, Node receivingNode ); 

} 

Pokaºimo odmah i jednu jednostavnu implementaciju oslu²kiva£a: 

Ispis 8.6: Jednostavna implementacija oslu²kiva£a dolaznih paketa 


public class SysoutReceiveListenerHr 

implements ReceiveListener 

{ 

public void packetReceived( Packet packet, Node receivingNode ) 

{ 


"ƒvor " + receivingNode.getName() + " je primio paket: " 

+ packet.getData() ); 

} 

} 

Klasa komunikacijskog £vora s podr²kom za oslu²kiva£e: 

Ispis 8.7: Komunikacijski £vor s podr²kom za oslu²kiva£e 


import java.util.HashSet; 

import java.util.Set;


public class Node 

{ 

private final Set recListeners = 

new HashSet(); 

} 

private final String name; 

public Node( String name ) 

{ 

this.name = name; 

} 

public void addReceiveListener( ReceiveListener listener ) 

{ 

this.recListeners.add( listener ); 

} 

public void receivePacket( Packet packet ) 

{ 

for ( ReceiveListener listener : this.recListeners ) 

listener.packetReceived( packet, this ); 

} 

public String getName() 

{ 

return this.name; 

} 

Napokon, pogledajmo primjer kako se sve ovo koristi. Gore je prikazana 

klasa oslu²kiva£a koja ispisuje poruku na hrvatskom; u primjeru koji slijedi 

pojavit ¢e se i klasa koja ispisuje poruku na engleskom. Cilj je prikazati 

situaciju s vi²e od jednog oslu²kiva£a. 

Ispis 8.8: Kori²tenje sustava 


{ 

Node node1 = new Node( "Node1" ); 

node1.addReceiveListener( new SysoutReceiveListenerEn() ); 

node1.addReceiveListener( new SysoutReceiveListenerHr() ); 

} 

Ispis: 

System.out.println( "’aljemo paket £voru..." ); 

node1.receivePacket( new Packet( "Testing Testing 1-2-3" ) ); 

’aljemo paket £voru... 

Node Node1 received packet: Testing Testing 1-2-3 

ƒvor Node1 je primio paket: Testing Testing 1-2-3


8.3 Adapter 

S primjerima uzoraka Adapter i Decorator susreli smo se u poglavlju o 

komunikaciji s okolinom, to£nije u odjeljku 7.2 o pisa£ima i £ita£ima. Podsjetimo 

se situacije koju smo imali. U ispisu 7.4 imamo metodu writeOutput( 

OutputStream ). Njen parametar, objekt vrste OutputStream, predstavlja odlazni 

tok podataka. To je je tzv. sirovi tok podataka jer se preko njega 

²alju £isti okteti, a ne npr. neki apstraktniji podaci kao ²to su znakovi. 

Mežutim, nama u implementaciji te metode upravo treba tok podataka u 

koji se mogu slati znakovi. To je zato ²to moramo pozvati metodu iz ispisa 

7.3, writeOutput( Writer ), koja o£ekuje da ju se pozove s pisa£em, ²to je 

Javin izraz za odlazni znakovni tok podataka. 

U praksi ¢emo tipi£no imati ve¢ gotove komponente koje rade sa znakovnim 

tokovima i ne znaju raditi druga£ije. Dakle, zamislimo da je metoda 

writeOutput( Writer ) ugražena u neku klasu za koju nemamo izvorni 

kod jer je ona dio biblioteke klasa koju samo koristimo, a ne razvijamo. 

Dovedeni smo u situaciju koja se £esto u praksi, u analogiji s elektrotehnikom, 

naziva impedance mismatch (neprilagoženost impedancija). S jedne 

strane imamo metodu koja o£ekuje znakovni tok, a s druge strane imamo 

sirovi tok u koji ta metoda treba slati podatke. Problem ¢emo rije²iti 

primjenom uzorka Adapter on ¢e nam adaptirati, tj. prilagoditi su£elje 

objekta koji imamo (sirovi tok) na su£elje objekta koji o£ekuje metoda 

iz biblioteke (znakovni tok). Moramo napraviti klasu adaptera sa sirovog 

na znakovni tok. U primjeru s ispisa 7.4 koristi se Javin adapter, klasa 

OutputStreamWriter. Pogledajmo kako bi ona mogla biti realizirana: 

Ispis 8.9: Pokazna izvedba adaptera na znakovni tok 




import java.io.Writer; 

public class OutputStreamWriter 

extends Writer 

{ 

private OutputStream os; 

public OutputStreamWriter( OutputStream os ) 

{ 

this.os = os;


} 

} 

@Override 

public void write( char[] cbuf, int off, int len ) 


{ 

for ( int i = off; i < off+len; i++ ) 

{ 

char c = cbuf[i]; 

if ( c < 0x80 ) 

os.write( c ); 

else 

os.write( '#' ); 

} 

} 

@Override 

public void flush() 


{ 

os.flush(); 

} 

@Override 

public void close() 


{ 

os.close(); 

} 

Ova jednostavna izvedba u sirovi tok propu²ta samo znakove iz podskupa 

Unicode-a zvanog Basic Latin, koji odgovara ASCII-ju, a umjesto 

svih ostalih znakova ²alje znak #. Primijetimo da su nadja£ane samo tri 

metode, dok klasa Writer posjeduje znatno ve¢i broj njih. To je zahvaljuju¢i 

tome ²to su sve ostale metode u toj klasi paºljivo izvedene tako da se 

oslanjaju na osnovnu funkcionalnost koju pruºaju samo ove tri. Na² adapter 

moºemo isprobati na primjerima iz 7. poglavlja tako da u na² paket dodamo 

klasu adaptera, a izbacimo izjavu import java.io.OutputStreamWriter. 

Alternativno, moºemo koristiti ovakvu metodu main, koju moºemo ubaciti 

u klasu OutputStreamWriter: 



{ 

Writer osw = new OutputStreamWriter( System.out ); 

osw.write( "Probni ispis\n" ); 

osw.close(); 

}


U drugom retku poziva se metoda write( String ), koju nismo eksplicitno 

nadja£ali, ali koja se oslanja na na²u metodu write( char[], int, int 

) 2 . 

Uzorak Adapter moºemo dosta pregledno vizualizirati UML-om. Na²a 

situacija prikazana je na slici 8.1. 

Client 

+writeOutput() 

Writer 

+write() 

+flush() 

+close() 

Client očekuje ovakav objekt 

Adapter 

Ovakav objekt 

imamo 

OutputStreamWriter 

OutputStream 

+write() 

+flush() 

+close() 

+write() 

+flush() 

+close() 

Slika 8.1: UML-ov dijagram uzorka Adapter 

8.4 Decorator 

Osim ²to £esto imamo situaciju koju rije²avamo Adapter-om, dakle nesuglasje 

izmežu su£elja koje nam treba i su£elja koje imamo na raspolaganju, 

£esto se pojavljuje i sli£na situacija u kojoj imamo objekt £ije su£elje odgovara, 

ali mu nedostaje jo² neka dodatna funkcionalnost. Dakle, nisu nam 

potrebne druga£ije metode (kao u slu£aju uzorka Adapter), ve¢ samo izmijenjeno 

pona²anje postoje¢ih metoda. Za takve situacije primjenjujemo 

uzorak Decorator. Iz re£enog ve¢ moºemo naslutiti da je ovaj uzorak dosta 

blizak uzorku Adapter dapa£e, njegova shema prikazana UML-om je identi£na. 

U poglavlju o komunikaciji imamo situaciju na kojoj moºemo prikazati 

ovaj uzorak. Tamo se pojavljuje klasa Reader koja predstavlja neki dolazni 

znakovni tok. Problem koji sad ºelimo rije²iti je sljede¢i: ve¢ raspolaºemo 

2 Metoda write( String ) je stoga jo² jedan primjer primjene uzorka Template method.


nekim objektom £ita£a, a ºelimo mu dodati funkciju korisnu prilikom tra- 

ºenja pogre²aka u programu da sve ²to pro£ita iz dolazne struje ispi²e i na 

zaslon radi kontrole. Naglasimo: ne kaºe se da raspolaºemo klasom £ita£a, 

£iji kod bismo mogli izmijeniti izravno, nego njenom instancom, dok samim 

izvornim kodom klase ne rapolaºemo. 

Kako ¢emo rije²iti ovaj problem? Denirat ¢emo novu klasu izvedenu 

iz klase Reader. Klasa, kao i kod Adapter-a, ima karakter omota£a. U ovom 

konkretnom slu£aju instanca na²e nove klase omota£ je za neki objekt vrste 

Reader. Dakle, u uzorku Decorator (hrv. ukra²iva£) klasa koju ukra²avamo 

pojavljuje se u dva konteksta odjednom: i kao vrsta ugraženog objekta 

(koji biva ukra²en), i kao natklasa ukra²iva£a. Najbolje je da prou£imo 

implementaciju na²eg ukra²iva£a: 



import java.io.Reader; 

public class DebugReader 

extends Reader 

{ 

private Reader rdr; 

Ispis 8.10: Primjer primjene uzorka Decorator 

public DebugReader( Reader rdr ) 

{ 

this.rdr = rdr; 

} 

@Override 

public int read( char[] cbuf, int off, int len ) 


{ 

// prvo prosliježujemo poziv na omotani objekt: 

int charsRead = this.rdr.read( cbuf, off, len ); 

// zatim obavljamo dodatne radnje: 

if ( charsRead != -1 ) 

System.out.println( "Reading " + 

String.valueOf( cbuf, off, charsRead ) ); 

return charsRead; 

} 

@Override 

public void close() 


{ 

// samo delegiramo na omotani objekt:


} 

} 

this.rdr.close(); 

Odmah moºemo uo£iti veliku sli£nost s primjerom za uzorak Adapter. 

Kod Adapter-a u igri su dvije razli£ite klase jer jednu prilagožavamo drugoj, 

a ovdje samo dodajemo funkcionalnost jednoj klasi, koja se stoga pojavljuje 

u dvostrukoj ulozi. 

Na²u klasu DebugReader moºemo isprobati na primjerima iz 5. poglavlja, 

tako da prepravimo ovu metodu iz ispisa 7.4: 



{ 

readInput( new InputStreamReader( is ) ); 

} 

Treba samo ubaciti jo² jedan omota£, na² ukra²iva£: 



{ 

readInput( new DebugReader( new InputStreamReader( is ) ) ); 

} 

Nakon toga moºemo isprobati primjere iz odjeljaka 7.37.5. 

Uzorak Decorator, kao ²to je najavljeno, u UML-ovom dijagramu izgleda 

vrlo sli£no kao Adapter. To se o£ituje na slici 8.2, na kojoj je jasno istaknuta 

dvojaka uloga ukra²avane klase 3 . 

Kao primjer kori²tenja uzorka Decorator u Javinoj biblioteci moºemo 

izdvojiti klase koje se pojavljuju u poglavlju o komunikaciji s okolinom: 

PrintWriter i BufferedReader. Te klase su i posebno zanimljive jer one istovremeno 

implementiraju i Adapter i Decorator: npr. klasa BufferedReader, 

osim ²to dodaje funkcionalnost mežuspremnika svim postoje¢im metodama 

(ukra²avanje), ima i dodatnu, vrlo zna£ajnu metodu readLine, koje nema 

u obi£nom Reader-u. Iz perspektive nekog koda koji o£ekuje da ¢e £ita£i 

imati upravo tu metodu, ona obavlja prilagodbu s obi£nog £ita£a na £ita£ 

s metodom readLine. 

3 Dijagram sa slike 8.2 nije sasvim korektan jer se ista klasa ne bi smjela crtati dvaput; 

mežutim, ispravan crteº ne bi bio tako jasan.


Client očekuje ovakav objekt 

Client 

+readInput() 

Reader 

+read() 

+close() 

Decorator 

Ovakav objekt 

imamo 

DebugReader 

Reader 

+read() 

+close() 

+read() 

+close() 

Slika 8.2: UML-ov dijagram uzorka Decorator

Poglavlje 9 

Savjeti za rad u Eclipse-u 

9.1 Automatizacija rada na kodu 

Razvojno okruºje Eclipse ima dosta bogatu zbirku alata koji automatiziraju 

mnoge aktivnosti na razvoju koda. Njihovim kori²tenjem kod se kreira 

brºe (puno manje tipkanja) i pouzdanije (Eclipse ne radi tipfelere). Preporu£a 

se detaljno prou£avanje menija Edit, Source i Refactor. Ovdje ¢e se 

spomenuti nekoliko najvaºnijih alata. 

Quick x aktivira se kombinacijom tipaka Ctrl-1 ili iz menija Edit. Pojavit 

¢e se mali prozor£i¢ u blizini kursora i ponudit ¢e razli£ite mogu¢nosti 

prepravljanja koda, i dodatno, ako se kursor nalazi na mjestu gdje je otkrivena 

pogre²ka, standardne na£ine njenog otklanjanja. Treba imati na umu 

ovo: Quick x ne zna bolje od vas! Student mora ve¢ znati kako treba 

ukloniti pogre²ku, Quick x je tu samo da taj postupak automatizira. Ako 

nasumice slu²ate savjete Quick x-a, najvjerojatnije je da ¢ete napraviti 

kaos u svom kodu. 

Rename in le je jedna od opcija koje nudi Quick x kad smo s kursorom 

unutar nekog identikatora. Opcija je dostupna i izravno pomo¢u Ctrl- 

2, R. Opciju koristimo uvijek kad ºelimo promijeniti ime nekoj lokalnoj 

varijabli, privatnom atributu/metodi i op¢enito bilo kojem identikatoru 

koji se koristi samo u trenutnoj datoteci. 

Content assist aktivira se pomo¢u Ctrl-Space ili iz menija Edit. Koristi 

se npr. na mjestu gdje ºelimo otipkati ime metode koju pozivamo. Ponudit 

¢e se sve metode denirane za objekt lijevo od to£ke. Npr. imamo varijablu 

String s i zapo£injemo novi redak koda tipkaju¢i 

s. 

119

120 POGLAVLJE 9. SAVJETI ZA RAD U ECLIPSE-U 

U ovom trenutku koristimo Ctrl-Space i uz kursor pojavljuje se popis svih 

metoda deniranih za String. Odaberemo pravu i njeno ime se ubacuje 

u kod. Ako je Eclipse odgovaraju¢e pode²en, izbornik Content Assist-a 

pojavit ¢e se i sam od sebe ako otipkamo to£ku i pri£ekomo koju sekundu 

(ovisno o brzini ra£unala). 

Content assist koristi se i za ekspanziju kodnih predloºaka: npr. mo- 

ºemo natipkati eq, pritisnuti Ctrl-space i odabrati equals. Time se ubacuje 

deklaracija metode equals. Isto radi i za toString, hashCode, main. Posebno 

koristan je predloºak sysout koji ubacuje £esto kori²tenu a duga£ku 

konstrukciju System.out.println(); Takožer su vrlo korisni predlo²ci for 

standardne petlje za prolazak po elementima polja ili kolekcije. Popis svih 

predloºaka moºe se pregledati i editirati pod Window, Preferences, Java, 

Editor, Templates. 

Organize imports aktivira se pomo¢u Ctrl-Shift-O ili iz menija Source. 

Kad god se pojavi pogre²ka da je neka vrsta podatka nepoznata, to je najvjerojatnije 

stoga ²to doti£na vrsta nije uvezena. Ovom naredbom automatski 

se pronalaze i uvoze sve potrebne vrste. Ako postoji vi²e vrsta istog 

imena, pojavit ¢e se prozor u kojemu treba odabrati pravu. Ova komanda 

takožer i uklanja nepotrebne uvoze, koji se trenutno ne koriste u kodu. 

Pomo¢u Rename moºemo promijeniti ime klasi, paketu, javnoj metodi i 

op¢enito bilo kojem identikatoru koji se koristi u vi²e datoteka. Dostupno 

iz menija Refactor ili pomo¢u Alt-Shift-R. 

Pomo¢u Move moºemo klasu preseliti u drugi paket i metodu/atribut u 

drugu klasu. Eclipse ¢e se pobrinuti da sva pozivanja na ono ²to se seli budu 

izmijenjena na odgovaraju¢i na£in, odnosno upozorit ¢e nas ako postoji 

prepreka preseljenju. Dostupno iz menija Refactor ili pomo¢u Alt-Shift-V. 

9.2 Povijest datoteke 

Ako shvatimo da smo krenuli s razvojem klase u pogre²nom smjeru, moºemo 

se vratiti na ranije stanje datoteke. U Package Explorer-u kliknemo desnim 

gumbom na na²u datoteku i odaberemo Replace with, Local history. Pojavit 

¢e se popis svih ranijih verzija datoteke koje su zapam¢ene.

POGLAVLJE 9. SAVJETI ZA RAD U ECLIPSE-U 121 

9.3 Seljenje projekta s ra£unala na ra£unalo 

9.3.1 Tipi£an problem prilikom selidbe 

Studenti se redovito susre¢u s potrebom da svoj projekt razvijaju na vi²e 

ra£unala u labosu, na svom laptopu, na ku¢nom ra£unalu itd. Projekt je 

prili£no jednostavno preseliti, ali jo² je jednostavnije to izvesti pogre²no, 

pogotovo stoga ²to je na raspolaganju £itav niz postupaka. Problemi nastaju 

zbog toga ²to postupak izvoza projekta nije usklažen s postupkom 

uvoza. Posebice, uo£ena je sljede¢a tipi£na pogre²ka: 

1. Projekt se ispravno izveze tako da glavno kazalo projekta sadrºi kazalo 

src koje je korijensko za datoteke s izvornim kodom. Ono ¢e 

tipi£no biti bez datoteka, samo s potkazalom hr. 

2. Na odredi²nom ra£unalu projekt se uveze tako da se kazalo src ne progla²ava 

korijenskim, ve¢ glavno kazalo projekta. Tako ispada da je src 

ustvari prvi segment imena paketa. Eclipse se sada ºali da deklaracija 

paketa u datoteci (npr. hr.fer.tel ²to je ispravno) ne odgovara 

kazalu u kojem se nalazi (src/hr/fer/tel ²to je neispravno!). 

3. Student odlazi na Quick x koji mu nudi izmjenu imena paketa u 

src.hr.fer.tel i time malu pogre²ku pretvara u puno ve¢u. To ponavlja 

za svaku datoteku. 

Ono ²to je zaista trebalo napraviti je popraviti korijenski direktorij izvornog 

koda. To se obavlja u Project, Properties, Java Build Path, Source. 

Tamo se nalazi okvir naslovljen Source folders on build path i unutra bi 

trebao biti navedeno kazalo src. Ako nije, dodajemo ga pomo¢u tipke Add 

folder... 

9.3.2 Savjeti za uspje²nu selidbu 

Sve datoteke projekta nalaze se na jednom mjestu. Potrebno je samo znati 

koje kazalo Eclipse koristi kao svoj Workspace. To se moºe doznati putem 

File, Switch Workspace. U tom kazalu za svaki projekt postoji po jedno 

potkazalo istog imena kao projekt. Op¢enito je dovoljno kazalo projekta 

preseliti na drugo ra£unalo, ponovo u kazalo tamo²njeg Workspace-a, pokrenuti 

Eclipse i pomo¢u File, New, Project, Java Project zatraºiti stvaranje

122 POGLAVLJE 9. SAVJETI ZA RAD U ECLIPSE-U 

projekta istog imena. Eclipse ¢e vas obavijestiti (u dnu dijalo²kog prozora) 

da kazalo tog imena ve¢ postoji i da ¢e sve postavke projekta biti preuzete. 

Eclipse nudi i izravnu podr²ku za selidbu projekta, kori²tenjem naredbi 

Export/Import. Na izvori²nom ra£unalu radimo ovo: 

1. U Package Explorer-u koristimo desni klik nad na²im projektom, zatim 

Export, Archive le 

2. Kad pritisnemo Next, nudi nam se mogu¢nost detaljnog odabira datoteka 

za izvoz. Datoteke .classpath i .project obvezno zadrºimo (tu 

su postavke projekta). Ako je bitno da arhiva bude ²to manja (mejl 

i sl.), moºemo izbaciti sva potkazala osim src. 

3. Niºe u dijalo²kom prozoru pomo¢u Browse odaberemo to£nu lokaciju 

i ime arhive koja ¢e se stvoriti. Provjerimo da su odabrane opcije Save 

in zip format i Create directory structure for les. 

4. Pritiskom na Finish izdajemo naredbu za stvaranje arhive. 

Stvorenu arhivu dopremamo do odredi²nog ra£unala na kojem pokre¢emo 

Eclipse i zatim: 

1. File, Import, Existing projects into Workspace. U dijalo²kom prozoru 

odabiremo opciju Select archive le i pomo¢u Browse nalazimo svoju 

arhivu. 

2. U dijalo²kom prozoru pojavljuje se popis svih projekata naženih u 

arhivi (trebo bi biti samo jedan). Provjerimo da je ime projekta ispravno 

i ozna£eno kva£icom. 

3. Pritiskom na Finish izdajemo naredbu za uvoz projekta.

Literatura 

[1] Java 2 Platform Standard Edition 5.0 API Specication. 

http://java.sun.com/j2se/1.5.0/docs/api. 

[2] Mary Campione, Kathy Walrath, and Alison Huml. The Java 

Tutorial. http://java.sun.com/docs/books/tutorial. 

[3] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. 

Design Patterns. Addison-Wesley Professional, 1995. 

[4] James Gosling, Bill Joy, Guy Steele, and Gilad Bracha. The Java 

Language Specication. 

http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html, 

2005. 

[5] James Gosling and Henry McGilton. The Java Language 

Environment, chapter 6: Security in Java. 

http://java.sun.com/docs/white/langenv/Security.doc.html. 

123

Skripta - FER

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?