Malbaski Programski Jezik Java 1h6b3d

{ P ob; public GenClass(P ob) { this.ob= ob; } public void setOb(P ob) { this.ob= ob; } public P getOb() { return ob; } }

Uočava se da generički parametar P figuriše kao tip polja ob, zatim kao parametar konstruktora i metode setOb, i kao tip rezultata metode getOb. Primeri instanciranja klase: GenClass<String> obs = new GenClass<String>(“ovo je string”); GenClass obt = new GenClass (new Tanjir(Tanjir.DUBOKI)); Skrećemo pažnju na još jednu stvar: klase dobijene konkretizacijom iste generičke klase nisu ni u kakvoj međusobnoj vezi! Prema tome, objekti obs i obt pripadaju različitim klasama i nisu kompatibilni ni po kojoj osnovi. Način ostvarivanja generičnosti opisan u ovoj tački ne zahteva eksplicitnu konverziju, što je, sa stanovišta izrade klijentskog softvera, svakako jedna od glavnih prednosti. U našem primeru, to bi značilo da se može pisati direktno String s = obs.getOb(); Tanjir t1 = obt.getOb();

7. Polimorfizam. Specijalne klase

177

Realizovaćemo stek iz prethodnog primera kao generički stek, sredstvima koja smo upravo opisali. Zapaža se da je konstruktor nešto izmenjen, a razlog su ograničenja generičkih klasa vezana za nizove, o kojima će još biti reči. Stack.java //Genericki stek public class Stack { private int top, capacity; private T[] body; //Konstruisanje praznog steka public Stack(int capacity) { this.body = (T[])new Object[capacity]; this.capacity= capacity; top= -1; }

izmena zbog ograničenja kod generičkih nizova

//Ocitavanje vrha steka public T top() { return body[top]; } //Uklanjanje elementa sa vrha steka public T pop() { if(isEmpty()) return null; else return body[top--]; } //Dodavanje elementa na vrh steka public void push(T el) { body[++top]= el; } //Da li je stek prazan? public boolean isEmpty() { return top<0; } //Da li je stek pun? public boolean isFull() { return top==capacity-1; } }

Definicija steka tanjiri iz prethodnog primera sada izgleda ovako: Stack tanjiri = new Stack (new Tanjir[10]);

Očitavanje vrha steka promenljivom t tipa Tanjiri više ne zahteva kastovanje: t= tanjiri.top();

bilo je t= (Tanjir)tanjiri.top()

Ovde treba imati na umu da su naredbe kao što je poslednja vrlo frekventne, te izostanak kastovanja znači pojednostavljenje izvornog koda, kao i činjenicu da se automatskim kastovanjem smanjuje verovatnoća greške, naročito u uslovima kada dejstvuje inkluzioni polimorfizam. Generičke klase omogućuju ograničavanje generičkog parametra odozgo. U do sada opisanom obliku, na mestu generičkog argumenta može se naći svaka klasa koja nasleđuje

7. Polimorfizam. Specijalne klase

178

klasu Object, tj. bilo koja klasa. Ukoliko je iz bilo kojih razloga potrebno ograničiti tip klase koja se može naći na mestu generičkog argumenta, ograničićemo skup generičkih argumenata iskazom ImeKlase

Sada se na mestu generičkog argumenta mogu naći samo klase koje nasleđuju klasu Q, uključujući i samu klasu Q. Na primer, u jedinstvenoj hijerarhiji klasa postoji klasa Number što je koren subhijerarhije klasa što predstavljaju objektnu realizaciju numeričkih baznih tipova int, lomg, double itd.66 Ako bismo generičku klasu Stack definisali sa public Stack {...} takav stek mogao bi za generičke argumente da ima samo numeričke tipove (tj. ne bi mogao da funkcioniše sa klasom Tanjir). Generički parametar može se ograničiti i drugim generičkim parametrom, npr. public G što bi značilo da drugi generički argument mora biti klasa koja nasleđuje prvi generički argument. 7.2.2. Džokerski parametri Generička klasa može da bude tip parametra neke metode. Tada se, međutim, javlja jedan problem. Posmatrajmo neku metodu m koja za parametar treba da ima objekat generičke klase GenClass

opisane u prethodnoj tački. Ako bismo metodu zadali sa tip_metode m(GenClass

par) { ... }

NE!

za P se ne bi moglo ustanoviti da li se radi o generičkom parametru ili generičkom argumentu tj. o konkretnoj klasi koja se zove P. U takvim situacijama koristi se tzv. džokerski parametar označen simbolom ?, koji se stavlja na mesto generičkog parametra. Dakle, tip_metode m(GenClass par) { ... }

DA!

Sada metoda m može za argument da primi objekat bilo koje klase koja konkretizuje klasu GenClass. Džokerski parametri mogu se ograničiti i odozgo i odozdo, s obzirom na relaciju nasleđivanja. U metodi tip_metode n(GenClass par) { ... } kao argument pri pozivu n može se naći objekat klase koja konkretizuje klasu GenClass ili GenClass<X> gde je X neka od klasa izvedenih iz Q. Slično, argument metode tip_metode p(GenClass par) { 66

Radi se o tzv. "omotačkim klasama" (engl. wrapper), videti sledeću glavu.

7. Polimorfizam. Specijalne klase

179

... } može biti objekat klase GenClass gde je Y neka od natklasa klase R, s tim da se R isključuje (tj. ne može biti objekat klase GenClass ). 7.2.3. Generičke metode Sve metode, nestatičke i statičke (uključujući i konstruktore), pored toga što slobodno raspolažu generičkim parametrima klase, mogu imati sopstvene generičke parametre. Odmah napominjemo da generički parametri pojedinačnih metoda nemaju nikakve veze sa generičkim parametrima klase, čak i ako se poklapaju po oznaci (što, dakle, treba izbegavati). Takođe, metode mogu biti generičke i u slučaju da sama klasa nije! Sintaksna oznaka generičnosti stavlja se ispred tipa metode. Na primer, metodu public static int genMethod(T x, V[] y) iz neke klase K pozivamo sa NE K.genMethod (a,b) K.genMethod(a,b) gde argument a ima tip NatKlasa, b je niz objekata tipa PotKlasa i PotKlasa nasleđuje NatKlasu. Uočimo: 

prilikom poziva generičke metode generički argumenti se ne navode!

Generički argumenti određuju se automatski, na osnovu tipa argumenata pri pozivu metode. 7.2.4. Sirovi tipovi i brisanje Pod pojmom sirovog tipa (engl. raw type) podrazumeva se, u stvari, stari način za realizaciju generičnosti opisan na početku ovog odeljka (direktna primena polimorfizma). S obzirom na to da je realizacija generičnosti unutar jave ostala nepromenjena po uvođenju generičkih klasa, generičnost se može ostvariti na oba načina. Generičku klasu GenClass

s početka tačke 7.2.1 možemo instancirati bez navođenja generičkih argumenata, dakle sa GenClass obs = new GenClass(“ovo je string”); s tim da se, naravno, prilikom korišćenja mora upotrebiti kast: String str = (String)obs.getOb(); Objašnjenje načina funkcionisanja generičkih klasa i njihove veze sa sirovim tipovima pruža postupak koji nosi naziv brisanje (engl. erasing). Da bi bio očuvan osnovni mehanizam za realizaciju generičnosti (inkluzioni+koercitivni polimorfizam), u postupak prevođenja uključen je segment koji modifikuje izvorni kod, tako da generički parametri i argumenti uopšte ne dospevaju u bajt-kod. Pomenuti deo postupka prevođenja jeste brisanje. U osnovi67 , radi se o jednostavnom postupku zamene generičkih parametara konkretnim klasama iz javine hijerarhije koji se izvodi tako što se generički parametar zamenjuje gornjom granicom ako je ima, odnosno klasom Object ako gornja granica nije navedena. Posmatrajmo jednostavnu klasu oblika public class K1

{ void met1(P x) { ... } P met2() { ... } 67

ali ne i u pojedinostima

7. Polimorfizam. Specijalne klase

180

}

U toku prevođenja ova klasa se biti modifikovana u public class K1 extends java.lang.Object { void met1(java.lang.Object x) { ... } java.lang.Object met2() { ... } }

i kao takva biće pretvorena u bajt-kod. Iz ovog primera vidimo i zašto svaka klasa nasleđuje klasu Object, direktno ili indirektno. Slično se razrešava i klasa sa generičkim parametrom koji je ograničen natklasom: public class K2 { void met3(Q x) { ... } Q met4() { ... } }

koja se razrešava sa public class K2 extends java.lang.Object { void met3(java.lang.String x) { ... } java.lang.String met4() { ... } }

Druga važna aktivnost je dodavanje eksplicitne konverzije u svim izrazima gde se pojavljuju generički argumenti. Recimo da je klasa K1 bila instancirana sa generičkim argumentom ConcreteClass gde je ConcreteClass konkretna klasa: K1 ob = new K1 ();

i da se u kodu nalazi naredba ConcreteClass z = ob.met2();

Ova naredba biće razrešena kastom ConcreteClass z = (ConcreteClass)ob.met2();

i to zato što metoda m2 vraća, ustvari, tip Object. 7.2.5. Generičke klase i nasleđivanje Generičke klase mogu nasleđivati i biti nasleđivane. Pritom, generička klasa može naslediti generičku klasu ili konkretnu klasu. Ono što, naravno, nije moguće jeste izvesti konkretnu klasu iz generičke iz prostog razloga što tada nema generičkog argumenta neophodnog natklasi. Prilikom nasleđivanja generički argument se prosleđuje natklasi (ako je generička). Evo jednostavnog primera: //Genericka natklasa public class GenSuperClass { protected T field; public void set(T field) { this.field= field; } public T get() { return field; }

7. Polimorfizam. Specijalne klase

181

} //Genericka potklasa public class GenSubClass extends GenSuperClass { public void showField() { System.out.println("Field value: "+field); } }

U potklasu je dodata metoda showField. Kako vidimo, nema nekih bitnih razlika u odnosu na nasleđivanje konkretnih klasa. Relacija instanceof važi i za generičke klase, s tim što se može proveravati samo pripadnost tipu generičke klase, što nije moguće za pripadnost tipu konkretizovane generičke klase. Neka je obsuper objekat natklase sa generičkim argumentom String, a obsub isto za potklasu konkretizovanu istim generičkim argumentom, tj. GenSuperClass<String> obsuper = new GenSuperClass<String>(); GenSubClass<String> obsub = new GenSubClass<String>(); Sledeće provere su moguće: obsub instanceof GenSuperClass //vrednost je true obsub instanceof GenSubClass //vrednost je true obsuper instanceof GenSubClass //vrednost je false Primena instanceof na konkretizovanu generičku klasu nije moguća, zbog brisanja koje eliminiše generički argument: obsub instanceof GenSubClass<String> //NE MOZE! I ostali mehanizmi vezani za nasleđivanje - posebno inkluzioni i koercitivni polimorfizam normalno funkcionišu sa generičkim klasama. 7.2.6. Ograničenja Korišćenje generičkih klasa podleže određenim ograničenjima. Ima ih više, a ovde ćemo se osvrnuti samo na najvažnija. Jedno smo već pomenuli: 

statički članovi klase ne mogu koristiti generičke parametre, ali statičke metode mogu imati sopstvene generičke parametre

Takođe, 

generički parametri ne mogu se instancirati

što je, uostalom, i za očekivanje jer se ne znaju parametri konstruktora. Ostala važnija ograničenja vezana su za nizove, koji i inače predstavljaju problem još od kada su se prvi put pojavili u procedurnom fortranu. 1. Ne može se kreirati niz konkretizovanih generičkih objekata. Neka je GenClass

generička klasa. Ono što se ne može uraditi jeste GenClass<String> g[] = new GenClass<String>[100] //NE! ali se zato može pisati

7. Polimorfizam. Specijalne klase

182

GenClass = new GenClass[100] //DA

2.

jer je to isto što i sirovi tip. Niz generičkih vrednosti može se definisati, ali se ne može instancirati.

Ova druga stavka itekako može da pravi probleme za slučajeve generičkih nizova koji su polja ili lokalni objekti u metodama. Pošto je problem isti i iziskuje ista rešenja posmatraćemo slučaj generičkog niza koji je polje. Vratimo se na primer generičkog steka iz primera u odeljku 7.2.1. Ono što bismo želeli jeste Stack.java

Može! Definisanje reference „body“ na generički niz

//Genericki stek public class Stack { private int top, capacity; private T[] body;

Ne! Pokušaj instanciranja generičkog niza body

//Konstruisanje praznog steka public Stack(int capacity) { this.body = new T[capacity]; this.capacity= capacity; top= -1; } ... itd.

Za rešavanje ovog problema na raspolaganju su dve tehnike. Jedna je 

realizovati generički niz kao parametar metode (u ovom slučaju konstruktora). Prilikom poziva dodeliti referencu na niz koji je argument (i čiji se, dakle, tip zna) referenci na generički niz.

U našem primeru, to bi izgledalo ovako: //Genericki stek public class Stack { private int top, capacity; private T[] body;

može

//Konstruisanje praznog steka public Stack(T[] body) { this.body= body; this.capacity= body.length; top= -1; } ... itd.

Drugo rešenje predstavlja kombinaciju generičke realizacije i eksplicitnog korišćenja inkluzionog i koercitivnog polimorfizma. Iako deluje rizičnije (u nekim slučajevima i jeste, jer nema provere tipa), ovo rešenje dobro funkcioniše kad god je generički niz skriven od klijenta. Ovu tehniku koristili smo u verziji datoj ranije: Stack.java //Genericki stek public class Stack { private int top, capacity; private T[] body; inkluzioni + koercitivni polimorfizam

7. Polimorfizam. Specijalne klase

183

//Konstruisanje praznog steka public Stack(int capacity) { this.body = (T[])new Object[capacity]; this.capacity= capacity; top= -1; } ... itd.

Slično bismo postupili i u slučaju da je generički niz lokalan za metodu m klase čiji je generički parametar P: public void m() { P[] gniz = (P[]) new Object[duzina]; ... itd. } Primer 7.4. Jedna od najvažnijih struktura podataka jeste tzv. red (red čekanja, engl. queue). U pitanju je linearna struktura u kojoj se pristupa prvom po redu elementu, uklanja se prvi, a dodaje se iza poslednjeg, slika 7.10.

pristup

uklanjanje

dodavanje

Slika 7.10. Red je dobio naziv red čekanja zbog jedinstvene osobine da se ranije uklanja onaj element koji je ranije i ušao u red. Ova osobina nosi naziv FIFO od First In First Out. Redovi se koriste kod prenosa podataka, u operativnim sistemima i u diskretnoj računarskoj simulaciji, u stvari svugde gde je neophodna njihova FIFO osobina. U ovom primeru napravićemo klasu SequentialQueue koja predstavlja sekvencijalno realizovan red čekanja. "Sekvencijalno realizovan" znači da se elementi upisuju u sukcesivne memorijske lokacije, u okviru unapred zauzetog segmenta memorije, zadatog kapaciteta. To znači da se ovakav red programski realizuje kao niz. Da bi se postigla generičnost, i to takva da u red može da se unese ma koji objekat, elementi niza, nazvanog elements, su tipa Object. Elementi se ređaju od nižih indeksa ka višim, tako da se očitava i briše prvi zauzeti element, a uklanja poslednji. Neka je dužina niza size. Ova realizacija ima jednu manjkavost koja bi, ako je ne uklonimo, bila dovoljna da se odustane od sekvencijalne realizacije. Radi se o pojavi tzv. "lažne prepunjenosti" reda. Posmatrajmo stanje reda prikazano na slici 7.11 gore. 0

1

2

size-1

...

a

b

getPosition

0

1

putPosition

2

size-1

...

a

getPosition

Slika 7.11.

b

c putPosition

7. Polimorfizam. Specijalne klase

184

Oznaka getPosition odnosi se na indeks prvog elementa, a putPosition na mesto iza poslednjeg elementa koje je predviđeno za upis pri izvođenju operacije dodavanja. Kako se vidi na istoj slici, na donjem crtežu, već posle jednog dodavanja elementa npr. c, poslednja raspoloživa lokacija u nizu je zauzeta, te bi novi pokušaj dodavanja rezultovao porukom o prepunjenosti memorijskog prostora! To, očigledno, nije tačno jer na drugom kraju reda ima mesta, samo se ona ne mogu popunjavati elementarnim algoritmom za dodavanje. Da bi se ovaj problem rešio, red se realizuje cirkularno (kružno) tako da se, kada se stigne do kraja memorijskog prostora, sa dodavanjem nastavlja na početku (naravno, ako ima mesta). Cirkularno rešenje prikazano je na slici 7.12 levo. Nažalost, ovo nije dovoljno jer se pojavljuje novi problem: (stvarno) popunjen red ne može se razlikovati od praznog reda jer u oba slučaja važi getPosition = putPosition. Ova situacija prikazana je na slici 7.12 u sredini i desno..

putPosition

pun red

getPosition

cirkularni red

prazan red

Slika 7.12.

Za ovaj problem ima više rešenja, a ovde ćemo opisati jedno, u svoje vreme prilično originalno. Ideja se sastoji u tome da se žrtvuje jedna lokacija u koju nije dozvoljen upis, što znači da je memorijski prostor reda za 1 lokaciju veći od stvarnog kapaciteta. Na taj način ostvaruje se razlika između praznog i punog reda. Dok je kod praznog reda i dalje getPosition=putPosition, pun red prepoznaje se po tome što su pozicije getPosition i putPosition susedne (u cirkularnom smislu), slika 7.13.

pun red

prazan red

Slika 7.13. Programski kôd klase ima sledeći izgled: SequentialQueue.java //Sekvencijalno realizovan red public class SequentialQueue { protected protected protected protected

T[] int int int

elements; size; getPosition; putPosition;

//Elementi //Velicina memorijskog prostora reda //Indeks sa kojeg se cita //Indeks na koji se upisuje

//Konstruktor SequentialQueue(int capacity) { size= capacity+1; elements= (T[])new Object[size];

7. Polimorfizam. Specijalne klase

185

getPosition= putPosition= 0; } //Upis elementa u red na mesto putPosition public void put(T element) { elements[putPosition]= element; putPosition= (putPosition+1)%size; } //Citanje elementa sa mesta getPosition public T get() { if(isEmpty()) return null; return elements[getPosition]; } //Uklanjanje elementa sa pocetka reda public T remove() { if(isEmpty()) return null; T el= elements[getPosition]; getPosition= (getPosition+1)%size; return el; } //Praznjenje reda public void clear() { getPosition= putPosition; } //Da li je red prazan? public boolean isEmpty() { return getPosition==putPosition; } //Da li je red pun? public boolean isFull() { return getPosition==(putPosition+1)%size; } //Kapacitet reda (za 1 manji od memorijskog prostora) public int capacity() { return size-1; } }

Klasa SequentialQueue realizovan je kao generička klasa, parametrizovana tipom (klasom) elemenata reda T. Pošto su elementi definisani tako da, posle brisanja, pripadaju klasi Object koja je bazna klasa svake klase u javi, standardne ili programirane, u red se može upisati objekat bilo koje klase K. Usput, videćemo u nastavku da se od baznih tipova int, double itd. mogu napraviti objekti, što znači da se u ovakve redove mogu upisati doslovno svi objekti i vrednosti svih tipova koji postoje u javi. Neka je obK objekat (ma koje) klase K. Nek aje q red konstruisan naredbom q = new SequentialQueue (100);

Upis objekta obK klase K vrši se direktnom primenom metode put, oblika q.put(obK);

7. Polimorfizam. Specijalne klase

186

Očitavanje elementa iz reda takođe se vrši direktno: obK= q.get();

7.2.7. Parametarski polimorfizam metoda Generičnost nije jedina vrsta parametarskog polimorfizma. Parametarski polimorfizam - inače, najstarija konstatovana vrsta polimorfizma - uočen je kod potprograma koji podešavaju ponašanje ne samo prema vrednosti argumenta nego i prema njegovom tipu. Inače, parametarski polimorfne metode (i potprogrami uopšte) više nisu deo onog što bismo nazvali visokokvalitetnim programiranjem. Primer 7.5. Pokazaćemo sada kako se na javi realizuje (parametarski) polimorfna metoda. Napravićemo metodu, baziranu na hijerarhiji trouglova iz primera 5.1, koja će biti u stanju da prepozna klasu argumenta (Trougao, PravougliTrougao, RavnostraniTrougao) i da uskladi svoje ponašanje sa tim. Pre nego što pređemo na realizaciju, valja napomenuti da mnogi autori ovakve metode i potprograme uopšte, ne smatraju delom dobrog stila programiranja, te ovu mogućnost ne treba preterano intenzivno koristiti. Metoda koju ćemo realizovati nosi naziv prikazTrougla, statička je i ima za zadatak da na ekranu prikaže osnovne podatke o trouglu-argumentu, pri čemu se ti osnovni podaci razlikuju u zavisnosti od vrste trougla. Za klasu Trougao to su dužine stranica, za pravougli trougao katete i hipotenuza, a za ravnostrani trougao stranica i visina. Parametarski polimorfizam ove metode postiže se kombinovanjem inkluzionog polimorfizma koji omogućuje slanje sve tri vrste argumenata, koercitivnog polimorfizma u vidu kasta, kao i relacionog operatora instanceof što omogućuje prepoznavanje klase argumenta koji je prosleđen metodi. Pošto metoda objašnjava samu sebe navodimo njen tekst bez suvišnog komentarisanja. public static void prikazTrougla(Trougao t) { if(t instanceof PravougliTrougao) System.out.println("PRAVOUGLI TROUGAO."+ " Kateta 1: "+((PravougliTrougao)t).kateta1()+ " Kateta 2: "+((PravougliTrougao)t).kateta2()+ " Hipotenuza: "+((PravougliTrougao)t).hipotenuza()); else if(t instanceof RavnostraniTrougao) System.out.println("RAVNOSTRANI TROUGAO."+ " Stranica: "+((RavnostraniTrougao)t).stranica()+ " Visina: "+((RavnostraniTrougao)t).visina()); else if(t instanceof Trougao) System.out.println("TROUGAO."+ " Stranica a: "+t.a()+ " Stranica b: "+t.b()+ " Stranica c: "+t.c()); System.out.println("Obim: "+t.obim()+ " Povrsina: "+t.povrsina()); }

Inače, bolje rešenje u objektnom smislu bilo bi da se, umesto jedne statičke metode, u svaku klasu uključi metoda za prikazivanje. Time bismo omogućili da se prikažu i objekti klasa koji će u budućnosti biti uključeni u hijerarhiju što nije moguće u navedenom primeru bez promene izvornog koda metode prikazTrougla.

7.3. APSTRAKTNE KLASE Neka je dat skup klasa geometrijskih figura u ravni, koji sadrži sledeće klase: Trougao, PravougliTrougao, RavnostraniTrougao, Pravougaonik, Kvadrat i Krug, slika 7.14.

7. Polimorfizam. Specijalne klase

Trougao

187

Pravougaonik

+obim():real +povrsina():real

+obim():real +povrsina():real

PravougliTrougao

RavnostraniTrougao

+obim():real +povrsina():real

+obim():real +povrsina():real

Krug +obim():real +povrsina():real

Kvadrat +obim():real +povrsina():real

Slika 7.13. Kako vidimo, neke među klasama su u vezi nasleđivanja, a neke nisu. Takođe - a to je ključno – sve imaju metode za računanje obima i površine (imaju, naravno, još metoda, ali ove su bitne za naše razmatranje). Neka je potrebno napraviti metodu koja za argument može da prihvati objekat iz bilo koje od navedenih klasa i koja manipuliše isključivo metodama obim i povrsina. To može, recimo, da bude metoda koja će na ekranu prikazati obim i površinu figure prosleđene kao argument. Pre svega, to apsolutno ima smisla, jer sve klase predstavljaju geometrijske figure u ravni i sve imaju metode za računanje obima i površine. Nažalost, već na prvom koraku, pri pokušaju da napišemo zaglavlje metode, nailazimo na prepreku: inkluzioni polimorfizam nije moguć jer klase nisu uređene u hijerarhiju sa korenom koji bi mogao da bude parametar naše metode. S druge strane, sasvim je logično da takvu klasu uvedemo, pošto klase sa slike 7.13 jesu srodne i sve predstavljaju geometrijske figure! Uvedimo, dakle, klasu Figura koja je bazna za klase Trougao, Pravougaonik i Krug, pa samim tim postaje koren hijerarhije, slika 7.14. Ovim ipak nismo rešili problem jer pri pokušaju da realizujemo klasu Figura opet nailazimo na prepreku, ovog puta znatno ozbiljniju s obzirom na sredstva kojima trenutno raspolažemo. Radi se o činjenici da metode obim i povrsina u klasi Figura ne možemo realizovati jer ne postoji formula za obim ili površinu proizvoljne geometrijske figure. Postoje samo formule za konkretne figure: trougao, pravougaonik, krug itd. Jedna od mogućnosti za prevazilaženje poteškoće mogla bi biti takva realizacija pomenutih metoda u kojoj se nalazi naredba za momentalno prekidanje programa, koja bi sprečila da se nepostojeća metoda izvrši. Ovo rešenje je moguće, ali nije dobro jer se greška pokazuje tek u toku izvršenja programa. Na sreću, java raspolaže boljim rešenjem68. Radi se o tzv. apstraktnim metodama i apstraktnim (Mejer ih naziva nepotpunim) klasama. Prvo, apstraktne metode su metode koje nemaju realizaciju te se, shodno tome, ne mogu aktivirati. Deklarišu se zaglavljem u kojem se među modifikatorima nalazi i modifikator abstract

Tako, apstraktne metode obim i povrsina u klasi Figura deklarišemo sa public abstract double obim(); public abstract double povrsina();

Sasvim logično, apstraktne metode ne mogu da se aktiviraju jer nema šta da se aktivira. One moraju biti redefinisane (upotrebljava se izraz operacionalizovane) što ukazuje na činjenicu da klasa koja sadrži apstraktne metode mora biti nasleđena. Takođe, klasa sa apstraktnim metodama ne sme se instancirati, jer bi odgovarajući objekat, zbog apstraktnih metoda, bio neupotrebljiv. Upravo od te činjenice se i polazi kada se u javi, dosta originalno, apstraktna klasa definiše kao 68

Nije jedina. Raspolažu i drugi razvijeni objektni programski jezici.

7. Polimorfizam. Specijalne klase

188

 klasa koja se ne može instancirati.

Figura {abstract} +obim():real {abstract} +povrsina():real {abstract}

Trougao

Pravougaonik

+obim():real +povrsina():real

+obim():real +povrsina():real

PravougliTrougao

RavnostraniTrougao

+obim():real +povrsina():real

+obim():real +povrsina():real

Krug +obim():real +povrsina():r

Kvadrat +obim():real +povrsina():real

Slika 7.14. Treba odmah uočiti da apstraktne klase ne moraju imati ni jednu apstraktnu metodu. Dovoljno je u okviru naredbe class među modifikatore uvrstiti modifikator abstract

Apstraktne klase mogu imati kontrolu pristupa public ili default. Dakle, kostur apstraktne klase je oblika pristup abstract ime_klase { . . . . . }

Suština apstraktnih klasa sastoji se u njihovoj nameni. Apstraktna klasa, naime, služi za to da "prikupi" zajedničke osobine više srodnih klasa, ma i po cenu sadržavanja apstraktnih metoda, i da odigra ulogu korene klase hijerarhije u koju strukturišemo pomenuti skup klasa. Kao i sve druge klase, pored toga što može biti nasleđivana, može i nasleđivati i to bez ikakvih ograničenja. Apstraktne metode se u izvedenim klasama operacionalizuju, ali i konkretne metode mogu biti redefinisane apstraktnim. Apstraktne klase se u UML prikazuju tako što se uz naziv dopisuje tekst {abstract}, a isto važi i za svaku apstraktnu metodu ponaosob (videti klasu Figura na slici 7.14). Prikazaćemo programski kod klase Figura. Sticajem okolnosti, a ne zato što je to često, u klasi Figura nema polja i nema konkretnih metoda. Klasa Figura izgleda ovako: Figura.java public abstract class Figura { public abstract double obim(); public abstract double povrsina(); }

7. Polimorfizam. Specijalne klase

189

Čitalac može sam realizovati ostale, konkretne, klase sa slike 7.14. Primenom klase Figura u stanju smo da izradimo metodu za prikaz na ekranu obima i površine ma koje figure predstavljene hijerarhijom klasa sa slike 7.14 i to bez primene koercitivnog polimorfizma (kasta). public static void prikazObimPovrsina(Figura f) { System.out.println("Obim: "+f.obim()+ "\nPovrsina: "+f.povrsina); }

Još jedan primer mogao bi da bude računanje zbira površina figura smeštenih u niz figura sa nazivom nizFigura: public double zbirPovrsina(Figura nizFigura[]) { double s; for(s=0,int i=0;i
Apstraktna klasa ne može se instancirati, ali se sme koristiti referenca na nju, dakako u sadejstvu sa inkluzionim i koercitivnim polimorfizmom. Nekoliko primera vezanih za geometrijske figure: Figura f = new Figura(); //Ne sme! Klasa Figura je apstraktna Figura fig1,fig2; //Moze fig1 = new Trougao(3,5,6); //Moze. Dodela potomka pretku Kvadrat kv = new Kvadrat(10); fig2= kv; //Referenca fig2 pokazuje na kvadrat System.out.println(((Kvadrat)fig2).obim()); //Kast Pravougaonik pr= (Pravougaonik)fig2; //Moze

Primer 7.6. U primerima 6.2, 7.3 i 7.3A (CD i DVD plejeri i kasetofon) klase sa uređajima i klase sa medijumima uređene su u hijerarhije sa korenim klasama Player i Medium. Ove klase zaštićene su nivoom default da se ne bi mogle instancirati iz klijenta. To, međutim, znači da njihovi identifikatori nisu dostupni, pa je samim tim klijent lišen mogućnosti upotrebe polimorfizma. Ako bi, iz ma kojeg razloga, trebalo napraviti npr. niz medijuma sve tri vrste, to bi bilo neizvodljivo s obzirom na neophodnost upotrebe nedostupnog identifikatora Medium u definiciji tog niza. Mnogo je bolje omogućiti upotrebu referenci na obe pomenute klase, a istovremeno sprečiti njihovo instanciranje. Kao prirodno rešenje, u ovom slučaju, nudi se korišćenje apstraktnih klasa. Klase Player i Medium treba proglasiti apstraktnim (uočimo: nemaju apstraktnih metoda!) čime se omogućava primena referenci, ali ne i instanciranje. Delovi korigovanog koda klasa Player i Medium imaju sledeći oblik (prikazan je samo izmenjeni deo) //Korena klasa za plejere package players; public abstract class Player { protected boolean on; protected boolean loaded; protected boolean playing; //Korenaprotected klasa za medijume boolean paused; package players; public abstract class Medium { //Ukljuciti private String name; public void switchOn() { public Medium(String name) { on= true; this.name= name; }

7. Polimorfizam. Specijalne klase

190

Primer 7.7. U liniji nasleđivanja Kicmenjak Ptica Orao ZlatniOrao sve klase osim poslednje nužno su apstraktne, pošto instanca klase npr. Ptica (tj. objekat koji bi bio samo ptica i ništa više) u prirodi ne postoji. Postoje samo konkretni orlovi, nojevi, pingvini itd. Pri tom, u klasi Kicmenjak nalaze se zajedničke osobine svih kičmenjaka (npr. dužina kičme), u klasi Ptica osobine koje nemaju svi kičmenjaci, a imaju sve ptice (recimo, osobine vezane za perje) itd.

7.4. INTERFEJSI Interfejs je komponenta koja se prividno gotovo poklapa sa apstraktnom klasom bez ijedne konkretne metode. Međutim, semantički, a naročito pragmatski (tj. u pogledu primene) interfejs se znatno razlikuje od apstraktne klase. Pre svega, interfejs – nije klasa. Kao što i sam naziv sugeriše, interfejs je komponenta jave koja služi isključivo za spregu klase sa klijentom, te možemo usvojiti radnu definiciju:  Interfejs je komponenta jave koja služi za spregu klijenta sa jednom ili više klasa povezanih sa njim specijalnom vrstom relacije. Dakle, interfejs je semantički nesamostalan ili, još preciznije, interfejs sam za sebe nema nikakvu funkcionalnost. Funkcionalnost, pa i semantika uopšte, ostvaruje se tek u klasi ili klasama za koje je interfejs vezan. Ma kako se na prvi pogled činilo, ova osobenost toliko je bitna da interfejse ni formalno ne ubrajamo u klase. Osobine interfejsa su sledeće: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.

Nema nijednu konkretnu (operacionalizovanu) metodu. Svi članovi interfejsa su public, bez obzira na to da li to eksplicitno piše ili ne. Ako i imaju polja (retko) ta polja tretiraju se kao static final. Sami interfejsi, kao i klase, mogu imati nivo zaštite public ili default. Kao ni apstraktne klase, ne mogu se instancirati (što bi bilo posebno besmisleno budući da nemaju nikakvu semantiku). Omogućuju polimorfno pridruživanje u svim oblicima, što je, sa pragmatskog stanovišta, najvažnija osobina. Interfejsi se međusobno mogu vezivati relacijom nasleđivanja extends, ali između klasa i interfejsa ovu relaciju nije moguće uspostaviti. Interfejs se, poput klase, može upotrebiti kao desni operand relacionog operatora instanceof. Levi operand je i dalje objekat. Klase se dovode u vezu sa interfejsima specijalnom vrstom relacije, sa nazivom implements, koja podseća na nasleđivanje, ali nije ista. Interfejs može biti generički

U UML interfejs se prikazuje simbolom klase sa dodatim stereotipom < > koji se navodi iznad naziva interfejsa, slika 7.15. < > naziv ..... .....

Slika 7.15. Interfejs se definiše posebnom naredbom koja nije class, baš da bi se podvuklo da se ne radi o klasi. Naredba se zove interface i, osim po nazivu, ne razlikuje se od naredbe class: modifikatori interface naziv { //polja (retko)

7. Polimorfizam. Specijalne klase

191

//zaglavlja metoda }

Klasa se vezuje za interfejs vezom operacionalizacije (implementacije), sa nazivom implements, koja ima sintaksni oblik kao veza nasleđivanja extends, a u UML se prikazuje prema slici 7.16. < > I

K

Slika 7.16.

Ako klasa sa nazivom K ima ovu vezu sa interfejsom I (kaže se "implementira interfejs") na javi se piše modifikatori class K implements I { //opis klase }

Broj klasa koje mogu da implementiraju isti interfejs je proizvoljan. Međutim, a za razliku od nasleđivanja, dozvoljava se da klasa implementira proizvoljan broj interfejsa. Uopšte uzev, data klasa (konkretna ili apstraktna) može da nasledi najviše jednu klasu i implementira više interfejsa, što je dato na slici 7.17. K1

< > I1

...

< > In

K2

Slika 7.17. Šema veza sa slike 7.17 se na javi prikazuje ovako: class K2 extends K1 implements I1,...,In { . . . . . }

Kako funkcioniše jedan interfejs? Pre svega, on može da funkcioniše samo u zajednici sa konkretnom klasom što implementira sve metode interfejsa. Posmatrajmo par koji čine klasa K2 i bilo koji interfejs Ij sa slike 7.17. Neka interfejs čine apstraktne metode m1,...mk. Definišimo referencu na interfejs sa nazivom refIj tako što ćemo joj dodeliti objekat klase K2: Ij refIj = new K2();

U daljem, referenca refIj ponaša se u skladu sa pravilima inkluzionog polimorfizma koji, kako smo rekli, važi i za relaciju implements podjednako kao za relaciju extends. Preko reference mogu se aktivirati samo metode m1,...,mk čija su zaglavlja u interfejsu Ij pri čemu se aktiviraju

7. Polimorfizam. Specijalne klase

192

verzije iz klase K2. Sve u svemu, postigli smo to da se kroz referencu refIj "vide" samo metode m1,...,mk deklarisane u interfejsu Ij. U nastavku, razmotrićemo nekoliko tipičnih situacija u kojima se primenjuju interfejsi. 7.3.1. Višestruka realizacija istog modela klase U programiranju je vrlo čest slučaj da se jedna klasa, posmatrana na nivou modela, realizuje na više načina, gde svaki ima neke prednosti i nedostatke. Na primer, klasa koja modeluje red (videti primer 7.4) može se realizovati sekvencijalno kao u pomenutom primeru, ali i spregnuto gde elementi nisu na susednim memorijskim lokacijama nego su povezani putem adresa (referenci). Veza se uspostavlja tako što se u dati element reda, pored njegovog redovnog sadržaja, upisuje i referenca na sledeći element u redu, tako da lokacije na kojima se nalaze elementi više nisu od interesa jer se veza ostvaruje softverski, slika 7.18.

Slika 7.18. Ovako realizovan red ima prednost nad sekvencijalnim utoliko što se ne može prepuniti jer se memorijski prostor ne zauzima unapred i smatra se, s obzirom na kapacitet operativne memorije, da mesta za novi element uvek ima. Nedostatak je u tome što su u ovakvom redu operacije dodavanja i uklanjanja nešto sporije. Bez obzira na realizaciju, sekvencijalnu ili spregnutu, red ima iste operacije: get, put, remove, isEmpty i isFull. Razlika je samo u njihovoj realizaciji. Da bi se to postiglo, treba primeniti šemu veza prema slici 7.19, gde je Queu interfejs, zatim SequentialQueue malo modifikovana verzija klase iz primera 7.4 i LinkedQueue spregnuta realizacija koja će biti detaljno prikazana u odeljku 7.3.2. Celu strukturu treba smestiti u paket sa nazivom queues. < > queues::Queue



+put(element:T) +get():T +remove():T +clear() +isEmpty():boolean +isFull():boolean



queues::SequentialQueue



queues::LinkedQueue

Slika 7.19. Programski tekst interfejsa Queue izgleda ovako: Queue.java package queues; public interface Queue { void put(T element); //public se podrazumeva

7. Polimorfizam. Specijalne klase

193

T get(); T remove(); void clear(); boolean isEmpty(); boolean isFull(); }

U interfejsu se nalaze sve metode koje su relevantne za obe realizacije. Metoda za očitavanje maksimalnog broja elemenata za spregnutu realizaciju ima vrednost "proizvoljno velik" te se zato ne nalazi u zajedničkom interfejsu. Metoda isFull u klasi LinkedQueue uvek vraća vrednost false. Metoda put u sekvencijalnoj realizaciji može da se izvrši samo ako red nije pun i zato vraća indikaciju o uspehu. U spregnutoj realizaciji (klasa LinkedQueue) tih ograničenja nema i zato u spregnutoj varijanti metoda uvek treba da vrati rezultat true. Pošto su izmene u klasi SequentialQueue minorne (samo uključivanje u paket queues), dok ćemo klasu LinkedQueue razmatrati kasnije, dajemo sasvim kratak tekst realizacije: package queues; public class LinkedQueue implements Queue ... package queues; public class SequentialQueue implements Queue { protected T[] elements; protected int size; protected int getPosition; protected int putPosition; . . . . .

Redovi se instanciraju preko interfejsa naredbama tipa (K je konkretna klasa) Queue qseq = new SequentialQueue (100); //Sekvencijalni red Queue qlink = new LinkedQueue () //Spregnuti red

Sledeći segment u kojem se pojavljuje red q uopšte ne zavisi od toga da li je q sekvencijalni ili spregnuti red: if(!q.isFull()) q.put(e1); x= q.get(); q.remove();

//el je tipa K

7.3.2. Podešavanje interfejsa klase (nasleđivanje implementacije) Pomoću komponente interface može se podešavati interfejs već izrađene klase čiji izvorni kod nije na raspolaganju. Ovaj postupak se, inače, zove i nesleđivanje implementacije). Da bismo izbegli nesporazum podvucimo da interfejs kao javina komponenta i interfejs klase nisu isto: dok je prvo komponenta jave sa nazivom interface, interfejs klase je i dalje ono što smo ranije definisali: skup članova klase koji su dostupni klijentu. Dakle, interfejs ne spada u sadržaj klase, a interfejs klase jeste esencijalni deo tog sadržaja! Neka je data neka klasa K za koju izvorni kod nije na raspolaganju. Neka je, dalje, potrebno podesiti interfejs klase tako da sadrži metode m1,...,mn od kojih su neke dodate, a neke redefinisane. Ovo se, naravno, bez poteškoća rešava nasleđivanjem, tako što se formira klasa K1 extends K. Šta se, međutim, dešava ako klasa K sadrži metode koje u klasi K1 nisu potrebne? Java - a ni drugi objektni jezici vredni pomena - nema mogućnost odbacivanja (nepreuzimanja) metoda, jer bi to stvorilo velike probleme zbog inkluzionog polimorfizma.

7. Polimorfizam. Specijalne klase

194

Ostaje drugo rešenje: sprečiti pristup metodama koje su višak ili, još bolje, propisati precizno koje metode se mogu koristiti. To se ostvaruje definisanjem interfejsa I što sadrži samo potrebne metode i vezivanjem klase K1 za taj interfejs, slika 7.20. < > I +m1(...) +m2(...) ..... +mn(...)

K

K1

Slika 7.20. Kada definišemo referencu I refK = new K1();

preko reference refK mogu se aktivirati samo metode m1,...mn sadržane u interfejsu I, tj. dostupno je samo ono što treba i ništa više. Primer 7.8. Pokazaćemo kako se primenom upravo opisane tehnike, "u tri poteza" može napraviti jednostruko spregnuti red iz primera 7.4. Naime, u standardnom paketu jave sa nazivom java.util postoji gotova generička klasa LinkedList što sadrži sve metode potrebne za realizaciju spregnutog reda i još mnogo više. Metode od interesa za naš zadatak jesu sledeće:     

metoda getFirst() za očitavanje prvog elementa liste metoda addLast() za dodavanje iza poslednjeg elementa liste metoda removeFirst() za uklanjanje prvog elementa liste metoda clear() za pražnjenje liste metoda isEmpty() za proveru da li je lista prazna.

Na slici 7.21 dat je dijagram klasa za realizaciju spregnutog reda čekanja. < > queues::Queue





java.util::LinkedList

+put(T element) +get():T +remove():T +clear() +isEmpty():boolean +isFull():boolean





queues::SequentialQueue

queues::LinkedQueue

Slika 7.21. Interfejs Queue.java dat je u odeljku 7.3.1. Klasa LinkedQueue izgleda ovako (uočimo primenu metoda iz klase LinkedList za realizaciju metoda u redu): LinkedQueue.java // Klasa red.

7. Polimorfizam. Specijalne klase

195

// Realizovan spregnuto nasledjivanjem klase LinkedList // i implementacijom interfejsa Queue. package queues; import java.util.LinkedList; public class LinkedQueue extends LinkedList implements Queue { public void put(T el) { addLast(el); } public T get() { return isEmpty() ? null : getFirst(); } public T remove() { return removeFirst(); } //clear() je vec implementirana u LinkedList! //isEmpty() je vec implementirana u LinkedList! public boolean isFull() { return false; } }

7.3.3. Više pogleda na istu klasu Ovde se radi o klasi za koju je vezano više interfejsa što omogućavaju više pogleda na istu klasu. Pokažimo odmah na primeru kako to izgleda. Već pomenuta klasa LinkedList iz paketa java.util može, istovremeno sa spregnutim redom, da implementira i interfejs Stack čime se, jednostavno kao i u slučaju reda, realizuje spregnuti stek. Za realizaciju spregnutog steka trebaju metode:     

metoda getFirst() za očitavanje prvog elementa liste metoda push() za dodavanje ispred prvog elementa liste metoda removeFirst() za uklanjanje prvog elementa liste metoda clear() za pražnjenje liste metoda isEmpty() za proveru da li je lista prazna.

Što se tiče druge implementacije, spregnuto realizovanog reda, programski tekst je isti kao u primeru 7.8. Na slici 7.22 prikazan je dijagram klasa za spregnute varijante reda i steka. Iza slike, dat je kôd interfejsa Stack i klase LinkedStack. Stack.java // Interfejs za ma kakav stek. public interface Stack { void push(T element); T top(); T pop(); void clear(); boolean isEmpty(); boolean isFull(); }

7. Polimorfizam. Specijalne klase

< > queues::Queue



196

< > Stack

+put(element:T) +get():T +remove():T +clear() +isEmpty():boolean +isFull():boolean



java.util::LinkedList

+push(element:T) +top():T +pop():T +clear() +isEmpty():boolean +isFull():boolean



queues::LinkedQueue



LinkedStack



Slika 7.22. LinkedStack.java // Klasa stek. // Realizovan spregnuto // nasledjivanjem klase LinkedList i interfejsa Stack. import java.util.LinkedList; public class LinkedStack extends LinkedList implements Stack { //push(T element) je vec implementirana u LinkedList! public T top() { return getFirst(); } public T pop() { return removeFirst(); } //clear() je vec implementirana u LinkedList! //isEmpty() je vec implementirana u LinkedList! public boolean isFull() { return false; } }

7.3.4. Interfejs kao zamena za enumeraciju Kao čist objektni jezik, java nema ni jedan izvedeni tip podataka, pa tako ni enumeraciju. Iako potreba za ovim tipom u javi nije velika, ako se ukaže može biti zadovoljena interfejsom sa poljima koja odgovaraju konstantama enumeracije. Polja imaju istu prirodu kao simboličke konstante u C/C++, tj. predstavljaju tzv. "compile time" konstante što se još u toku prevođenja zamenjuju pridruženim vrednostima. Podsetimo se, sva polja u interfejsu su uvek public final, te se to može, a ne mora, napisati. Evo jednostavnog primera interfejsa u ulozi enumeracije sa nekoliko boja iza kojih stoje celobrojne vrednosti. Boja.java //Interfejs u ulozi enumeracije public interface Boja { int CRVENA =0;

7. Polimorfizam. Specijalne klase

int int int int int

PLAVA ZELENA ZUTA CRNA BELA

197

=1; =2; =3; =4; =5;

}

Vrednosti se koriste kao i sve statičke konstante, npr. Boja.CRVENA ili Boja.ZUTA. Inače, počev od verzije J2SE5, u javu je uvedena nova komponenta, koja nije klasa i nije interfejs, nosi naziv enum i ima osobine enumeracije snabdevene nekim metodama. 7.3.5. Interfejs kao filter Neka je m neka metoda koja treba da bude primenljiva na tačno određen skup klasa K1,...Kn koje međusobno nisu vezane relacijom nasleđivanja. Na koji način obezbediti da metoda m za argument prihvati sve objekte navedenih klasa i samo njih? Jedno rešenje bilo bi uvesti neku apstraktnu klasu koja je bazna za sve klase K1,...,Kn. Šta, međutim, ako neka od ovih klasa već eksplicitno nasleđuje? Pošto java nema višestrukog nasleđivanja, ovo rešenje u opštem slučaju nije moguće. Stoga ćemo, umesto nasleđivanja klase, upotrebiti implementaciju interfejsa gde se, videli smo, ne propisuje broj interfejsa koji se nasleđuju. Napravićemo, jednostavno, interfejs I (može biti i prazan, bez metoda) i u svaku klasu Kj koja pretenduje na to da bude argument metode m uključiti kvalifikator implements I

tako da se svaki objekat klase Kj ponaša i kao instanca interfejsa I. S druge strane, u parametre metode m uključićemo parametar tipa I, tako da ma koja instanca klase Kj j=1,...,n može da bude upotrebljena kao argument. Primer 7.9 Neka je Printer klasa koja modeluje sasvim jednostavan štampač sa samo dve metode: jedna, sa nazivom printString štampa string. Druga metoda sa imenom print treba da prikaže objekat koji je pripremljen za štampu time što obavezno sadrži metodu format za formatiranje izlaza (pretvaranjem u string). Kao filter što propušta u metodu print samo objekte klasa sa metodom format iskoristićemo interfejs Printable sa jednom metodom format (). Dijagram klasa prikazan je na slici 7.23 (uočiti vezu korišćenja između Printer i Printable. Trougao

< > Printable

<<use>>

+format():string

Printer +printString() +print(Printable obj)

RavnostraniTrougao +format():string ....

Slika 7.23. Printer.java public class Printer { //Stampanje objekta public void print(Printable obj) { System.out.print(obj.format()); } //Stampanje stringa public void printString(String s) {

7. Polimorfizam. Specijalne klase

198

System.out.print(s); } }

Printable.java //Interfejs koji proverava da li objekat moze da se stampa //(tj. da li ima metodu format) public interface Printable { String format(); }

Da bi se objekti klase mogli koristiti kao argumenti metode print klase Printer, klasa RavnostraniTrougao mora se pripremiti tako što implementira interfejs Printable i sadrži metodu format. RavnostraniTrougao.java public class RavnostraniTrougao extends Trougao implements Printable { //Konstruktor public RavnostraniTrougao(double s) { super(s,s,s); } //Ocitavanje duzine stranice i visine public double stranica() { return a; } public double visina() { return 0.866025403*a; } //Racunanje obima i povrsine public double obim() { return 3*a; } public double povrsina() { return 0.433012701*a*a; } //Pretvaranje u string (zbog stampe) public String format() { return "Stranica: "+stranica()+ " Visina: "+visina()+ "\nObim: "+obim()+ " Povrsina: "+povrsina(); } }

Primer štampanja ravnostranog trougla: Printer stampac = new Printer(); RavnostraniTrougao tr = new RavnostraniTrougao(10); stampac.print(tr);

7.5. UNUTRAŠNJE KLASE Unutrašnja klasa je nesamostalna klasa koja je članica druge klase ili je čak definisana unutar neke metode (prvi slučaj je značajniji). Deklariše se kao i svaka druga klasa, samo što je deklaracija u celosti sadržana u deklaraciji klase kojoj pripada (u daljem tekstu

7. Polimorfizam. Specijalne klase

199

spoljašnje klase). Zapazimo da isto važi i za druge članove klase: polja su promenljive ili objekti definisani unutar klase, metode su potprogrami definisani unutar klase. Opšta šema klase koja sadrži unutrašnju klasu je modifikatori class Spoljasnja_klasa { modifikatori class Unutrasnja_klasa { //opis unutrasnje klase } . . . . . . . . . . }

UML prikaz je dat na slici 7.24. Spoljasnja_klasa

Unutrasnja_klasa

Slika 7.24. Kako unutrašnja klasa predstavlja član spoljašnje kao i svaki drugi, to  

može imati nivo zaštite private, default, protected ili public može, po potrebi, biti statička (modifikator static) kada njen sadržaj treba da bude dostupan statičkim metodama spoljašnje klase.

Može se instancirati samo preko objekta spoljašnje klase: Spoljasnja_klasa s = new Spoljasnja_klasa(); Spoljasnja_klasa.Unutrasnja_klasa u = new s.Unutrasnja_klasa();

Drugim rečima ne može se pisati nešto poput Spoljasnja.Unutrasnja u = new Spoljasnja.Unutrasnja();

Ovo poslednje i nije tako važno jer je primarna svrha unutrašnjih klasa 

korišćenje za interne potrebe spoljašnje klase.

U toj ulozi, unutrašnja klasa je najčešće zaštićena tako da se njome manipuliše isključivo iz spoljašnje klase, dok je za ostale klase nedostupna. Shodno osnovnoj svrsi unutrašnje klase, važi pravilo: 

Svi članovi unutrašnje klase dostupni su iz spoljašnje i to bez obzira na sopstveni nivo zaštite (uključujući čak i private).

Do sada smo u više navrata koristili spregnutu listu, kao linearnu strukturu realizovanu korišćenjem referenci. Logička struktura (struktura nivoa modela) liste je linearna, oblika prikazanog na slici 7.25.

Slika 7.25. Jednostruko spregnuta lista se fizički realizuje tako što se svaka veza prikazana strelicom implementira kao referenca na sledeći element ili, preciznije, kao referenca na sledeći element. Neka je potrebno napraviti generičku listu List čiji su elementi tipa Object. Tada format svakog elementa ima oblik prikazan na slici 7.26.

7. Polimorfizam. Specijalne klase

200

ListElement info:T

next:ListElement

Slika 7.26. Kako vidimo, svaki element liste je objekat (klase, recimo, ListElement) koji ima dva polja: jedno je polje tipa Object sa korisnim sadržajem elementa, a drugo je next tipa ListElement što predstavlja referencu na isti takav element. Pošto klijenta interesuje samo polje info, kompletan element liste (sa referencom next) ne treba da bude dostupan, pa čak ni njegov tip. Najbolje rešenje je klasu ListElement realizovati kao unutrašnju klasu klase List. Sama lista nije ništa drugo do referenca na prvi element, dok se ostali nalaze na hipu. Prvih nekoliko metoda klase List izgledaju ovako69 : List.java public class List { //Unutrasnja klasa private class ListElement { private T info; private ListElement next; } private ListElement first; //Konstruisanje prazne liste public List() { first= null; } //Da li je prazna? public boolean isEmpty() { return first==null; } //Dodavanje elementa na pocetak liste public void addFirst(T el) { ListElement newEl = new ListElement(); newEl.info= el; newEl.next= first; first= newEl; } .... itd. }

Dakle, primenom unutrašnje klase obezbeđeno je da klasa ListElement bude nevidljiva za sve klijente. Primer 7.10. Vratimo se opet primeru spregnuto realizovanog reda. Pokazaćemo kako se uz pomoć unutrašnje klase red može tako inkapsulirati da sve neophodne operacije budu i jedino dostupne. Operacije neophodne za upotrebu reda su konstruisanje, dodavanje i uklanjanje elementa, pristup elementu, pražnjenje reda i provera da li je red prazan ili je pun, pri čemu poslednja operacija za spregnuti red daje uvek rezultat false (spregnuti red ne može se napuniti), slika 7.27.

69

Nema potrebe prikazivati celu listu, jer java ima gotovu generičku klasu LinkedList koju smo već koristili.

7. Polimorfizam. Specijalne klase

201

LinkedQueue.makeQueue() put(T element) T get() remove():T clear() isEmpty() isFull()

Slika 7.27. Centralni deo čini klasa LinkedQueue koja obezbeđuje sve operacije nad redom. Klasa je apstraktna da se ne bi mogla instancirati, no to nije sve. Realizacija operacija ne nalazi se u njoj, nego u klasi PLinkedQueue koja je unutrašnja, te se ne vidi ni iz jednog klijenta. Klasa PLinkedQueue nasleđuje klasu LinkedList zbog realizacije metoda i implementira interfejs Queue. Posebno je zanimljiv način na koji se red konstruiše, a s obzirom na to da konstruktor apstraktne klase LinkedQueue nije na raspolaganju. Zbog toga, operacija se izvodi statičkom generičkom metodom makeQueue definisanom u klasi LinkedQueue uz primenu interfejsa Queue. Konstrukcija reda sa konkretnom klasom K kao generičkim argumentom izgleda ovako: .........(7.1)

Queue myQueue = LinkedQueue.makeQueue();

Konačno, zapazimo da je unutrašnja klasa PLinkedQueue statička i generička, zato što je metoda makeQueue koja služi za instanciranje takođe statička, a opšte pravilo je da se statičke metode mogu obraćati samo statičkim članovima klase. UML prikaz klasa dat je na slici 7.28. < > Queue



LinkedQueue {abstract}

java.util::LinkedList



PLinkedQueue

Slika 7.28. Queue.java // Interfejs za ma kakav red. package queues; public interface Queue { void put(T element); T get(); T remove(); void clear(); boolean isEmpty(); boolean isFull(); }

LinkedQueue.java package queues;



7. Polimorfizam. Specijalne klase

202

import java.util.LinkedList; public abstract class LinkedQueue { public static Queue makeQueue() { return new PLinkedQueue (); } private static class PLinkedQueue extends LinkedList implements Queue { //Upis elementa public void put(U element) { addLast(element); } //Citanje elementa public U get() { return isEmpty() ? null : getFirst(); } //Uklanjanje elementa public U remove() { return removeFirst(); } //clear je vec implementirana u LinkedList //isEmpty() je vec implementirana u LinkedList public boolean isFull() { return false; } } }

U statičkoj metodi makeQueue za generički parametar namerno je upotrebljena drukčija oznaka V da bi se podvuklo da on nema veze sa generičkim parametrom U klase PLinkedList. Usklađivanje tipova vrši se tek prilikom poziva u naredbama kao što je (7.1). 7.5.1. Komunikacija spoljne i unutrašnje klase. Anonimne klase Unutrašnje klase ne moraju da budu samo članice spoljašnjih. Mogu se definisati i unutar metoda, ali i unutar ma kojeg bloka. Jedino ograničenje u ovim slučajevima postaje domet takve unutrašnje klase koji se, naravno, sada svodi na metodu ili na blok. Kada se govori o komunikaciji između spoljašnje i unutrašnje klase, naročitih novosti u pogledu kontrole pristupa nema: pošto je unutrašnja klasa članica spoljašnje, svi njeni delovi otvoreni su za spoljašnju klasu, bez obzira na sopstveni nivo zaštite. Novost je komunikacija u obrnutom smeru: unutrašnja klasa pristupa sadržaju spoljašnje bez posebnog kvalifikovanja. Dakle, metoda m1() spoljašnje klase poziva se iz neke metode unutrašnje klase konstruktom m1(). Posebno, ako postoji kolizija imena (isto ime metoda spoljašnje i unutrašnje klase, recimo m2()), tada se metoda spoljašnje klase pri aktiviranju iz unutrašnje, kvalifikuje konstruktom sastavljenim od imena spoljašnje klase i polja this: Spoljasnja_klasa.this.m2();

Tzv. anonimne unutrašnje klase jesu poseban oblik klasa. To su bezimene klase koje se navode u celosti u okviru instanciranja. U UML dodaje im se stereotip < >.Posmatrajmo jedan veštački primer (realan primer može se naći u primeru 8.2 u sledećem poglavlju). Neka je dat interfejs AnInterface i klasa ClassWithAnonimous u kojoj se nalazi anonimna unutrašnja klasa. Dajemo prvo njihove kodove:

7. Polimorfizam. Specijalne klase

203

AnInterface.java public interface AnInterface { void inc(); void dec(); }

ClassWithAnonimous.java //Klasa sa anonimnom unutrasnjom klasom public class ClassWithAnonimous { private int x; ClassWithAnonimous() { x= 0; } int get() { return x; } //Metoda sa unutrasnjom klasom koja konkretizuje AnInterface public AnInterface value() { return new AnInterface() { public void inc() { x++; } public void dec() { x--; } }; } }

U metodi value() zapažamo čudnu naredbu: instanciranje klase pomoću "konstruktora" AnInterface! Ovo se svakako ne može objasniti pravilima jave do sada razmatranim, stoga što se radi o novom pravilu. Označena naredba čita se 

Konstruisati objekat anonimne (bezimene) klase date u nastavku, pri čemu anonimna klasa nasleđuje ili implementira klasu-interfejs sa imenom datim u konstruktoru.

Još nešto: ako anonimna klasa nasleđuje, tada se koriste realni konstruktori. Konačno, kratka ilustracija primene: public class Main { public static void main(String args[]) { ClassWithAnonimous cwa = new ClassWithAnonimous(); AnInterface intf = cwa.value(); System.out.println(cwa.get()); intf.inc(); //Povecanje x za 1. Sada je x jednako 1. intf.inc(); //Povecanje x za 1. Sada je x jednako 2. System.out.println(cwa.get()); intf.dec(); System.out.println(cwa.get()); } }

8. STRINGOVI, OMOTAČI I KOLEKCIJE. KLASA Class U sastav sofverskog sistema što čini javu ulazi mnoštvo klasa različite namene, raspoređenih u više paketa. Standardni paketi u javi su: 1. Paket java.lang sa klasama opšte namene. Paket je uvek na raspolaganju i ne mora se povezivati naredbom import. 2. Paket java.util sa dodatnim uslužnim ("utility") klasama, opet opšte namene. 3. Paket java.io sa klasama namenjenim transferu podataka, tj. ulazu-izlazu. 4. Paket java.net sa klasama namenjenim za programiranje mrežnih aplikacija. Podsećamo: sve klase u javi, bez obzira na to da li su standardne ili nisu, nasleđuju klasu Object. Vrlo upadljiva karakteristika sistema standardnih klasa, pored njegove obimnosti, jeste ta da se on neprestano menja, po formi i sadržini. Stalno se dodaju nove klase, ali se i postojeće klase modifikuju, pri čemu ovo poslednje nije naročita prednost. Naime, s vremena na vreme neke klase odn. metode bivaju zamenjene boljim rešenjima, što zbog objektivnih razloga (npr. prelazak na UNICODE u paketu java.io), što zbog pogrešno koncipiranih metoda (metode suspend i resume u klasi Thread namenjenoj konkurentnom programiranju). Ima i zamene usled pogrešno odabranih naziva (klasa Enumeration koja nije enumeracija ili metoda hasNextElement sa predugačkim nazivom). Za ove klase i metode upotrebljava se eufemizam deprecated, retka reč koja bi značila otprilike "nije više tako dobro". U okviru ovog poglavlja daćemo pregled nekih od najvažnijih klasa iz paketa java.lang i java.util. U pitanju su klase široke primene koje, zbog mnoštva metoda, nećemo opisivati u celosti.

8.1. KLASE STRING I STRINGBUFFER Sa klasom String upoznali smo se u odeljku 3.7.4. Pošto se radi o veoma važnoj klasi, dajemo širi pregled njenih osobina. Tip podataka string ima tu osobinu da može da bude "nosač" putem kojeg se može proslediti ma koji bazni tip: sve što smo u stanju da predstavimo tekstom može se preneti putem stringa. U javi, string je klasa sa nazivom String u paketu java.lang i sa nekim specijalnim osobinama po kojima se razlikuje od običnih klasa. Većinu smo obradili u pomenutom odeljku, no ipak ćemo ponoviti ukratko:  

Postoje string-konstante predstavljene konstruktom "sadrzaj stringa". Postoji operacija nivoa stringa, sa nazivom spajanje ili konkatenacija, kojom se dva stringa spajaju u jedan. Operacija se predstavlja znakom +. Dakle, konkatenacija dva stringa, s1 i s2, jeste s1+s2. Njoj je srodna i operacija nastavljanja += kojom se na levi operand nadodaje desni. Dakle, s1+= s2 je isto što i s1=s1+s12.

8. Stringovi, omotači i kolekcije



205

Objekti klasa koje imaju metodu toString() mogu da zamene string kao argumenti metoda. Pri prenosu takvog objekta automatski se vrši konverzija u string pomoću pomenute metode.

Stringovi klase String imaju još dve važne karakteristike:  

Predstavljaju konstantne stringove, tj. stringove čiji se sadržaj ne može menjati. Promenljivim stringovima manipuliše se pomoću klase StringBuffer. Iako se, kao i svi objekti, string prenosi u metodu po referenci, postoji jedna razlika: izmena stringa unutar metode nema uticaja na argument, kao da je u pitanju prenos po vrednosti.

Pošto su objekti klase String konstantni stringovi, postavlja se pitanje šta se dešava kada takvom stringu promenimo sadržaj. Neka je, na primer, str string definisan sa String str = "ABCD";

Ako se sada izvrši naredba str += "EF";

prvo će se spojiti stringovi "ABCD" i "EF", a zatim izvesti dodela, pri čemu se adresa novog stringa "ABCDEF" dodeljuje referenci str. Drugim rečima, pre odnosno posle naredbe str+="EF" referenca str ne pokazuje na isti objekat. Ukoliko želimo da manipulišemo promenljivim stringovima (što nije preterano čest slučaj), prinuđeni smo da koristimo klasu StringBuffer. U klasi String postoji više od 10 konstruktora što kreiraju string na bazi različitih objekata. Među njima nalaze se i sledeći: String() String(char value) String (String strOrig) String(StringBuffer strBuff)

Konstruisanje praznog stringa Konstruisanje stringa iz znakovnog niza Konstruisanje stringa iz drugog stringa strOrig Konstruisanje stringa na bazi objekta strBuff klase StringBuffer

Najinteresantnije metode klase String jesu: int char char[]

length() charAt(int i) toCharArray()

boolean

equals(Object str)

boolean

equalsIgnoreCase(Object str)

int

compareTo(Object str)

int

indexOf(char ch)

String

replace(char orig, char repl)

String

toLowerCase()

String

toUpperCase()

Dužina stringa Očitavanje i-tog znaka u stringu Generisanje ekvivalentnog niza znakova Provera jednakosti sa stringom str Isto uz ignorisanje razlike između velikih i malih slova Upoređivanje sa stringom str. Porede se pojedinačni znakovi prema redosledu u kodu. Rezultat je "manji", "jednak" ili "veći" Indeks prve pojave znaka ch u stringu Zamena svih pojava znaka orig znakom repl Očitavanje stringa uz zamenu velikih slova malim Očitavanje stringa uz zamenu malih slova velikim

8. Stringovi, omotači i kolekcije

static String

valueOf(boolean b)

Pretvaranje tipa boolean u string

static String

valueOf(char c)

Pretvaranje znakovnog tipa u string

static String

valueOf(char[] chArr)

Pretvaranje znakovnog niza u string

static String

valueOf(int i)

Pretvaranje tipa int u string

static String

valueOf(long l)

Pretvaranje tipa long u string

static String

valueOf(float f)

Pretvaranje tipa float u string

static String

valueOf(double d)

Pretvaranje tipa double u string

static String

valueOf(Object o)

Pretvaranje tipa Object u string

206

Klasa StringBuffer je srodna klasi String, ali ne u meri u kojoj to naziv sugeriše. Dok klasa String po strukturi predstavlja statički niz što modeluje tekst, klasa StringBuffer jeste dinamički niz čiji su elementi pojedinačni znakovi. Klase nisu u vezi nasleđivanja i nemaju iste metode. Pored toga, u klasi StringBuffer nema konstanata niti je definisana najvažnija string-operacija - konkatenacija. Prema tome, ova klasa predstavlja dinamički niz znakova koji, po potrebi, može da posluži i u svrhu realizacije stringova promenljive dužine, ali i kao običan znakovni bafer. Sam bafer ima dve veličine vezane za broj znakova: vrednost length jednaku aktuelnom broju znakova i vrednost capacity koja predstavlja kapacitet bafera. Ako dodavanjem sadržaja broj elemenata pređe kapacitet, kapacitet bafera se automatski povećava tako da ne može doći do prepunjenosti. Konstruktori klase StringBuffer su dati u sledećoj tabeli: StringBuffer() StringBuffer(int capacity) StringBuffer(String str)

Kreira bafer standardnog kapaciteta 16 znakova. Kreira bafer kapaciteta capacity Kreira bafer sa početnim sadržajem str i kapacitetom str.length()+16

Slede neke od važnijih metoda u klasi StringBuffer: int length() Aktuelni broj znakova u baferu int capacity() Kapacitet bafera char charAt(int i) Očitavanje znaka na i-toj poziciji u baferu void setCharAt(int i, char ch) Upis znaka ch na i-tu poziciju u baferu StringBuffer append(X el) Dodavanje string-reprezentacije el na kraj bafera, gde X može biti bilo koji primitivni tip kao i tip char[], String i StringBuffer. Vraća izmenjeni bafer. StringBuffer insert(int i, X el) Umetanje el na mesto i u baferu. Za X važi isto kao kod metode append. Vraća izmenjeni bafer. StringBuffer delete(int start, int end) Brisanje sadržaja bafera od pozicije start do end. Vrednost start uključno, vrednost end isključno. StringBuffer deleteCharAt(int i) Brisanje znaka sa pozicije i StringBuffer replace(int start, int end, Zamena dela bafera između pozicija start i String str)

8. Stringovi, omotači i kolekcije

String

207

end stringom str. Vrednost start uključno, vrednost end isključno. Konverzija u string

toString()

8.2. OMOTAČI Posmatrajmo generičku klasu G, realizovanu bilo direktno bilo kao G gde je T generički parametar. U svim slučajevima klasa G može da funkcioniše sa objektima bilo koje javine klase, jer sve klase nasleđuju klasu Object. Šta se, međutim, dešava ako je potrebno da se na mestu generičkog argumenta nađe neki od baznih tipova. Kako ostvariti, na primer, red ili stek koji će da čuva podatke int ili char, kada ti podaci nisu objekti? Do odgovora dolazimo brzo: treba napraviti odgovarajuće klase sa poljem koje sadrži podatak i metodama za pretvaranje podatka baznog tipa u odgovarajući objekat i obrnuto. Pošto je u pitanju standardan, uvek isti, postupak, takve klase su napravljene i uključene u javinu hijerarhiju, u paket java.lang. To su jednostavne klase sa nazivom omotači (engl. wrapper) čiji je zadatak da od baznih tipova naprave objekte, tačnije da na osnovu baznih tipova konstruišu analogne objekte, kao i obrnuto. Za svaki od baznih tipova, java ima odgovarajući omotač sa konstruktorom što, na osnovu vrednosti baznog tipa, konstruiše odgovarajući objekat. Omotači su, osim omotača za tipove boolean i char, uređeni u subhijerarhiju sa apstraktnom klasom Number u korenu, slika 8.1. Object

Number

Integer

Character

Long

Boolean

Float

Double

Slika 8.1. Ovu grupu klasa čine omotači:      

Boolean za logički tip Character za tip char Integer za tipove int, byte i short Long za tip long Float za tip float i Double za tip double.

Omotači se koriste uvek kada treba koristiti neki od baznih tipova kao objekat. Evo jednog primera: u prethodnom poglavlju napravili smo klasu SequentialQueue sa interfejsom Queue, koja predstavlja sekvencijalni red čekanja. Neka je u taj red potrebno upisivati znakove. Odmah zapažamo da to nije moguće direktnim upisom, budući da su elementi reda čekanja definisani kao objekti klase koja je generički parametar (i koja se posle brisanja pretvara u klasu Object). Da bi se ostvario red sa znakovnim elementima, oni se moraju pretvoriti u objekte i upravo to jeste osnovni zadatak odgovarajućeg omotača, Character. Red se definiše sa

8. Stringovi, omotači i kolekcije

208

Queue charQueue = new SequentialQueue (100);

Upis elementa u red vrši se naredbom charQueue.put(new Character('x');

a očitava se naredbama tipa char chEl= charQueue.get().charValue();

gde je chEl (sic!) promenljiva tipa char, a charValue() metoda za očitavanje znakovne vrednosti objekta klase Character. Sadržaj omotačkih klasa vrlo je sličan, te ćemo ga ilustrovati samo jednom klasom, klasom Integer i to ne u celosti nego preko najvažnijih polja i metoda. Klasa Integer sadrži, pored ostalog, sledeće važne članove: Integer(int i) Integer(String str) static int

MIN_VALUE

static int

MAX_VALUE

boolean

equals(Object ob)

int

intValue()

byte

byteValue()

short

shortValue()

long

longValue()

float

floatValue()

double

doubleValue

String

toString()

static String

toString(int i)

static String

toBinaryString(int i)

static String

toOctalString(int i)

static String

toHexString(int i)

konstruktor konstruktor sa stringom str kao parametrom najmanja vrednost tipa int najveća vrednost tipa int provera jednakosti vrednost konvertovana u tip int vrednost konvertovana u tip byte vrednost konvertovana u tip short vrednost konvertovana u tip long vrednost konvertovana u tip float vrednost konvertovana u tip double konverzija vrednosti u string konverzija int promenljive i u string. Dobija se dekadni prikaz konverzija int promenljive i u string. Dobija se binarni prikaz konverzija int promenljive i u string. Dobija se oktalni prikaz konverzija int promenljive i u string. Dobija se heksadecimalni prikaz

8.2.1. Automatsko pakovanje i raspakivanje U praksi, korišćenje omotača svodi se gotovo isključivo na pretvaranje baznog tipa u odgovarajući objekat i obrnuto. Stoga je u novije verzije jave uključeno tzv. automatsko pakovanje i raspakivanje, tj. automatsko pretvaranje baznog tipa u objekat i vice versa. Postupak je do te mere automatizovan da se važno!



manipulisanje vrednostima baznog tipa i objektima odgovarajućeg omotača izvodi kao da je u pitanju isti tip!

Posmatrajmo promenljivu i baznog tipa int i objekat obI tipa Integer. Automatsko pakovanje i raspakivanje omogućuje da u svim situacijama promenljiva i i objekt obI mogu da zamene jedno drugo, uključujući i dodelu

8. Stringovi, omotači i kolekcije

i = obI

odnosno

209

obI = i

Shodno tome, napred navedenim redom charQueue može se rukovati i ovako: charQueue.put('x'); char chEl= charQueue.get();

U praksi, pretvaranje baznog tipa u omotač i obrnuto praktično uvek sprovodi se korišćenjem automatskog pakovanja i raspakivanja.

8.3. KONTEJNERSKE KLASE I ITERATORI Kontejnerska klasa (skr. kontejner) je generička klasa što predstavlja objektnu realizaciju strukture podataka. Očigledno, klase s kojima smo se već susretali, Stack, Queue i LinkedList su, u stvari, kontejnerske klase. Kontejnerskih klasa u javi ima mnogo70, a između njih izdvojićemo tri: 1. Klasa ArrayList 2. Klasa LinkedList i 3. Klasa HashMap. Pošto im je svrha ista - organizovanje podataka - strukture podataka, pa prema tome i kontejnerske klase, međusobno se razlikuju po vrsti i kvalitetu operacija. Iz mnoštva operacija izdvajamo četiri: pristup elementu (u cilju čitanja ili modifikacije sadržaja), uklanjanje (brisanje) elementa, dodavanje elementa i sistematski pristup svim elementima (proces znan kao iteriranje ili redosledna obrada). Već po karakteristikama ovih operacija može se napraviti prilično jasna granica između različitih vrsta kontejnera. Kontejnerske klase nalaze se u paketu java.util i sve su generičke. Java ima poseban način za rukovanje kontejnerskim klasama. Da bi se to istaklo, za kontejnersku klasu uveden je novi termin - kolekcija i oformljen poseban interfejs(!) sa nazivom Collection. Ovaj interfejs garantuje da sve klase koje ga implementiraju moraju imati standardan skup operacija koji dajemo u nepotpunom obliku, izdvajajući samo one metode koje se često koriste. Sam interfejs je generički sa definicijom interface Collection<E>

Interfejs Collection (nepotpun) int boolean

add(E el)

boolean

remove(Object el)

void

70

size()

clear()

boolean

isEmpty()

boolean

contains(Object el)

Object[]

toArray()

Iterator<E>

iterator()

Očitavanje aktuelnog broja elemenata Dodavanje elementa el; u slučaju neuspeha71 vraća false Uklanjanje jedne instance elementa el. Rezultat je true u slučaju uspeha, inače false Uklanjanje svih elemenata Provera da li je kolekcija prazna Provera da li kolekcija sadrži objekat el. Proverava se sadržaj (ne referenca!) Konverzija kolekcije u niz Vraća iterator72 zadate kolekcije

usput, postoje i gotove kontejnerske klase (tačnije interfejsi) Stack i Queue neke konkretne kolekcije imaju ograničenja pri dodavanju (npr. dupliranje ključa, ako ima ključeva) 72 iterator je poseban mehanizam koji omogućuje sukacesivan pristup svim elementima kolekcije 71

8. Stringovi, omotači i kolekcije

210

Podvucimo još jednom: navedene metode sadrže sve kontejnerske klase (kolekcije) u javi, jer sve implementiraju interfejs Collection. 8.3.1. Klasa ArrayList Dinamički generički niz elemenata klase E nosi naziv ArrayList. Inače, dinamički niz, kao struktura podataka, odlikuje se sledećim osobinama: 1. U svakom trenutku dozvoljen je pristup svakom elementu i to mehanizmom indeksiranja, tj. preliminarnog izračunavanja pozicije. 2. Ukloniti se može svaki element. 3. Dodaje se na bilo kojem mestu: na početku, između ma koja dva susedna elementa ili na kraju. Upravo zahtev za pristupanje putem indeksiranja s jedne i uklanjanje-dodavanje bez ograničenja s druge strane, diktira poseban način za fizičku realizaciju dinamičkog niza. Prvo, zbog indeksiranja, niz nužno mora biti realizovan sekvencijalno. Nasuprot tome, operacije dodavanja i uklanjanja zahtevaju promenu dužine memorijskog prostora. Da bi se ovi suprotstavljeni zahtevi pomirili, dinamički niz realizuje se kao memorijska zona koja je popunjena do određene adrese, a zatim slede nezauzete lokacije. Takođe, a u cilju izbegavanja prepunjenosti, dodeljeni memorijski prostor može se proširiti dodavanjem novog bloka, ali i skratiti ako je popunjeni segment mnogo manji od ukupnog dodeljenog prostora. Pristup indeksiranjem podrazumeva preliminarno računanje adrese elementa. Ako je d dinamički niz i ako je potrebno pristupiti elementu di čiji je indeks i, njegova relativna adresa računa se na bazi jednostavne formule adr(di) = i   gde je  kapacitet (veličina) jednog elementa dinamičkog niza izražena u adresibilnim jedinicama. Da bi ova formula bila primenljiva, jasno je da aktuelni elementi u svakom trenutku obavezno čine neprekinut niz u memoriji. To pak znači da se operacije uklanjanja i dodavanja izvršavaju nešto sporije (nego kod običnog statičkog niza) jer se elementi moraju preurediti. Prilikom dodavanja, u opštem slučaju, elementi koji slede novododati moraju se pomeriti za jedno mesto prema kraju niza da bi oslobodili prostor za novi element. Posle uklanjanja nekog elementa, oni elementi koji su ga sledili moraju se pomeriti za jedno mesto ka početku niza. Na slici 8.2 prikazana je realizacija dinamičkog niza, kao i operacije dodavanja i uklanjanja. kapacitet

size()

dodavanje

uklanjanje

Slika 8.2. Klasa ArrayList<E> je tipičan dinamički niz. Kapacitet memorijskog prostora dodeljenog dinamičkom nizu održava se (povećava i smanjuje) automatski, bez preteranog uplitanja programera, iako izvesna sredstva ipak postoje: metodom void ensureCapacity(int capacity) čiji je parametar capacity može da se zada minimalni kapacitet memorijskog prostora, a u svrhu ubrzanja operacije dodavanja. Stvarna dužina (broj elemenata) niza dobija se metodom size(). Ako posle određenog broja dodavanja elemenata u zoni više nema mesta,

8. Stringovi, omotači i kolekcije

211

niz se automatski rekonfiguriše tako što se kapacitet poveća dodavanjem bloka čija se veličina određuje automatski. U vezi sa metodom ensureCapacity je i metoda trimToSize koja uklanja višak memorijskog prostora sastavljen od nezauzetih lokacija ostavljajući samo aktuelne elemente. Navedene dve metode ne spadaju u često korišćene. Klasa ArrayList zamenila je, u svojstvu dinamičkog niza, klasu koja se iz nejasnih razloga zvala Vector. Klasa Vector i dalje postoji, ali samo radi kompatibilnosti sa starijim verzijama, te se njena upotreba ne preporučuje. Navodimo neke od važnijih metoda klase ArrayList: Klasa ArrayList<E> ArrayList () ArrayList (int capacity) ArrayList (Collection collection) int boolean void

size() add(E el) add(int i, E element)

E

set(int i, E el)

E

get(int i)

E

remove(int i)

void

clear()

boolean

isEmpty()

boolean

contains(Object el)

int

indexOf(Object el)

Object[]

toArray()

void

ensureCapacity(int minCapacity)

void

trimToSize()

Kreiranje praznog niza Kreiranje niza sa početnim kapacitetom capacity Kreiranje niza iz kolekcije collection Očitavanje aktuelnog broja elemenata Dodavanje elementa el na kraj Dodavanje elementa el na indeksu i Upis elementa el na indeks i. Stari sadržaj se vraća kao rezultat Vraća element sa indeksom i Uklanjanje elementa sa indeksom i. Rezultat je uklonjeni element Uklanjanje svih elemenata Provera da li je niz prazan Provera da li niz sadrži objekat el. Proverava se sadržaj (ne referenca!) Vraća indeks elementa el (proverava se sadržaj) Konverzija u statički niz Zadaje minimalni kapacitet memorijskog prostora parametrom minCapacity Uklanja nezauzete lokacije (skraćuje niz)

Klasa ArrayList (i svaki dinamički niz) objedinjava neke karakteristike statičkih nizova (indeksiranje) i jednostruko spregnutih listi (mogućnost dodavanja i uklanjanja), uz određena ograničenja (potreba rekonfigurisanja), te je zato važno znati kada se upotrebljavaju. U opštem slučaju, ArrayList ćemo koristiti  

kada se elementi karakterišu pozicijom, te je potrebno indeksiranje i kada je istovremeno potrebno obezbediti mogućnost dodavanja i uklanjanja elemenata, ali ne preterano čestog.

Primer 8.1. Kao ilustraciju primene klase ArrayList realizovaćemo klasu Voz što predstavlja model železničke kompozicije sastavljen od pojednostavljenih modela lokomotive i raznih vrsta vagona. Komponente voza uređene su u hijerarhiju prikazanu na slici 8.3. Koren hijerarhije je apstraktna klasa SinskoVozilo sa jednim poljem što predstavlja oznaku vozila i odgovarajućom metodom za očitavanje oznake. Ovu klasu nasleđuju još jedna apstraktna klasa Vagon i konkretna klasa Lokomotiva. Konačno, klasa Vagon konkretizuje se u klase što modeluju različite tipove vagona. U klasi Lokomotiva, pored polja sa oznakom nasleđenom iz bazne klase, nalazi se još samo sadržaj koji modeluje kretanje lokomotive. U vagonima nalaze se polja i odgovarajuće metode što predstavljaju samo njihove najvažnije, definicione

8. Stringovi, omotači i kolekcije

212

osobine. Pošto su konkretne klase sasvim pojednostavljene i samoobjašnjavajuće, dajemo njihov kôd bez suvišnog komentarisanja. public abstract class SinskoVozilo { protected String oznaka; public SinskoVozilo(String oznaka) { this.oznaka= oznaka; } public String getOznaka() { return oznaka; } } public abstract class Vagon extends SinskoVozilo { public Vagon(String oznaka) { super(oznaka); } }

SinskoVozilo {abstract}

0..1 Vagon

Lokomotiva

{abstract} 0..* Voz

PutnickiVagon

TeretniVagon

Cisterna

VagonRestoran

Slika 8.3.

public class PutnickiVagon extends Vagon { protected int brojSedista; public PutnickiVagon(String oznaka, int brojSedista) { super(oznaka); this.brojSedista= brojSedista; } public int getBrojSedista() { return brojSedista; } } public class TeretniVagon extends Vagon { protected int nosivost; public TeretniVagon(String oznaka, int nosivost) { super(oznaka); this.nosivost= nosivost;

Kuset

8. Stringovi, omotači i kolekcije

213

} public int getNosivost() { return nosivost; } } public class Cisterna extends Vagon { protected int zapremina; public Cisterna(String oznaka, int zapremina) { super(oznaka); this.zapremina= zapremina; } public int getZapremina() { return zapremina; } } public class VagonRestoran extends Vagon { protected int brojStolova; public VagonRestoran(String oznaka, int brojStolova) { super(oznaka); this.brojStolova= brojStolova; } public int getBrojStolova() { return brojStolova; } } public class Kuset extends Vagon { protected int brojLezaja; public Kuset(String oznaka, int brojLezaja) { super(oznaka); this.brojLezaja= brojLezaja; } public int getbrojLezaja() { return brojLezaja; } } public class Lokomotiva extends SinskoVozilo { protected int brzina; //Brzina u procentima (neke) maksimalne public Lokomotiva(String oznaka) { super(oznaka); brzina= 0; } public void setBrzina(int brzina) { this.brzina= brzina; } public int getBrzina() { return brzina; } public boolean isStoji() { return brzina==0; } }

Čitalac, nadamo se, neće zameriti na upotrebi "serbgleske" mnemonike, tj. mešanja engleskih prefiksa sa srpskim nastavkom. Razlog su, naravno, standardni prefiksi "get", "is" itd. Klasa Voz ima dva polja: jedno je referenca na klasu Lokomotiva, a drugo dinamički niz predviđen

8. Stringovi, omotači i kolekcije

214

za čuvanje referenci na vagone što čine železničku kompoziciju. Konstruktori su koncipirani tako da se voz može inicirati sa lokomotivom ili bez nje. U potonjem slučaju, lokomotiva se uključuje u voz metodom addLokomotiva. Pošto je brzina voza isto što i brzina lokomotive, ali samo kada je ima, u klasu su uključene metode za manipulisanje brzinom kretanja, getBrzina, setBrzina i isStoji. Posebno, metodom vagoni() pristupa se nizu koji sadrži reference na vagone. Kod klase Voz ima sledeći izgled: Voz.java import java.util.ArrayList; public class Voz { private Lokomotiva lok; private ArrayList vagoni; public Voz() { this.lok= null; vagoni= new ArrayList (); } public Voz(Lokomotiva lok) { this.lok= lok; vagoni = new ArrayList (); } public boolean addLokomotiva(Lokomotiva lok) { if(this.lok!=null) return false; else { this.lok= lok; return true; } } public Lokomotiva getLokomotiva(){ return lok; } public Lokomotiva removeLokomotiva() { Lokomotiva result = lok; lok= null; return result; } public boolean hasLokomotiva() { return lok!=null; } public boolean setBrzina(int brzina) { if(lok==null) return false; else { lok.setBrzina(brzina); return true; } } public int getBrzina() { if(lok==null) return 0; else return lok.getBrzina(); } public boolean isStoji() { if(lok==null) return true; else return lok.isStoji(); } public ArrayList getVagoni() { return vagoni;

8. Stringovi, omotači i kolekcije

215

} }

Evo primera formiranja železničke kompozicije: //Konstruisanje objekat "voz" Lokomotiva lokom = new Lokomotiva("LK01"); Voz voz = new Voz(lokom); PutnickiVagon pVag1 = new PutnickiVagon("PV01",100); PutnickiVagon pVag2 = new PutnickiVagon("PV02",120); PutnickiVagon pVag3 = new PutnickiVagon("PV03",80); TeretniVagon tVag1 = new TeretniVagon("TV01",5); TeretniVagon tVag2 = new TeretniVagon("TV02",10); Cisterna cist = new Cisterna("CS01",1000); //Ukljucivanje vagona u voz voz.getVagoni().add(pVag1); voz.getVagoni().add(tVag1); voz.getVagoni().add(pVag2); voz.getVagoni().add(pVag3); voz.getVagoni().add(tVag2); voz.getVagoni().add(cist); System.out.println("Broj vagona: "+voz.getVagoni().size());

8.3.2. Iteratori Neka je u prethodnom primeru potrebno izračunati ukupan broj mesta u svim putničkim vagonima. Da bi se to ostvarilo treba pregledati ceo niz, element po element, i za svaki putnički vagon na ukupan broj sedišta dodati odgovarajući broj u tom vagonu. Programski segment ima sledeći izgled: int tot,i; for(tot=0,i=0;i
Složena operacija kojom se prolazi kroz ceo niz (i svaku drugu strukturu podataka koja to dozvoljava) nosi naziv iterator. U suštini, iteratori su složene, ali ne i komplikovane operacije. Sastoje se od tri dela:   

inicijalizacioni deo provera da li postoji sledeći element i pristup sledećem elementu.

Ova tri dela lako se mogu identifikovati u gornjem segmentu. Iteratori se najviše upotrebljavaju za tzv. redoslednu (sekvencijalnu) obradu struktura podataka, koja podrazumeva obradu svakog elementa strukture podataka. Iterator u javi jeste generički interfejs koji obezbeđuje metode za sistematsko pristupanje svim elementima kolekcije. Radi se o jednostavnim interfejsima (ima ih dva) sa po dve-tri metode, pa se postavlja pitanje zašto oni uopšte postoje? Ovo utoliko više jer iz gornjeg segmenta vidimo da je i sama realizacija prolaza kroz niz jednostavna. Razlog za uvođenje posebnog interfejsa-iteratora jeste uniformnost. Naime, prolaz kroz kolekciju potreban je za klasu ArrayList, ali i za druge kontejnerske klase, poput HashMap ili LinkedList, pa eventualno i za kolekcije koje programer formira za sopstvene potrebe. Pošto se radi o istim metodama sa (vrlo) različitim realizacijama, a u skladu sa principom očuvanja semantike, one treba da nose isti naziv i da postoje u svakoj klasi koja ima iterator.

8. Stringovi, omotači i kolekcije

216

Java poseduje tri iteratora – stariju verziju Enumeration, noviju verziju Iterator i poseban oblik naredbe ciklusa for prilagođen nizovima i kolekcijama. Počećemo sa poslednjim navedenim, jer je najjednostavniji. Specijalni oblik naredbe for za iteriranje kroz nizove i kolekcije odavno je poznat u analizi algoritamskih struktura kao naredba for-each. Opšti oblik ove naredbe u javi je for(TipElementa imeElementa : ImeNiza ili ImeKolekcije) naredba Ciklus for-each odvija se tako što se sukcesivno pristupa svim elementima niza ili kolekcije preko reference imeElementa i izvršava se naredba. Za razliku od osnovnog ciklusa for, programer nema kontrolu nad samim redosledom pristupanja elementima. Sve što se garantuje jeste to da će biti pristupljeno svim elementima i za svaki od njih biti izvršena naredba. TipElementa predstavlja tip elemenata niza ili kolekcije na koje se primenjuje naredba for. Inače, kolekcija kroz koju se iterira implementira poseban interfejs nazvan Iterable. Segment za računanje ukupnog broja sedišta sa početka ovog odeljka sada dobija sledeći izgled: int tot=0; for(Vagon vag:voz.getVagoni()) if(vag instanceof PutnickiVagon) tot+= ((PutnickiVagon)vag).getBrojSedista();

Dodajmo još, da je domet upravljačke promenljive u ciklusu (u našem slučaju vag) sam ciklus, te se može definisati pod istim imenom u svakoj naredbi for. Osnovna prednost naredbe for-each je njena jednostavnost, a glavni nedostatak jeste činjenica da na redosled pristupa programer nema uticaja. Ukoliko je, recimo, za neku kolekciju potrebno realizovati iteriranje unatrag, ova naredba neće biti od pomoći, što važi i za primenu metodu remove za uklanjanje. Kako se potreba specijalnim efektima ne pojavljuje često, a budući da je naredba for-each primenljiva na sve kolekcije, treba je smatrati standardnim načinom iteriranja. Iterator sa nazivom Iterator<E> izveden je kao generički interfejs koji je već implementiran u svakoj kolekciji (kao i for-each). Nalazi se u paketu java.util. Ima svega tri metode: Interfejs Iterator<E> hasNext() Vraća true sve dok ima još nepregledanih elemenata. Inače false. E next() Vraća sledeći element. void remove() Uklanja iz kolekcije element koji je pročitan pomoću next() boolean

Do instance iteratora dolazi se metodom iterator() koja se nalazi u svakoj kolekciji. Prikazaćemo ponovo programski segment za računanje ukupnog broja sedišta s početka ovog odeljka, uz primenu iteratora: int tot=0; Vagon vag; Iterator iter = voz.getVagoni().iterator(); while(iter.hasNext()) { vag= iter.next(); if(vag instanceof PutnickiVagon) tot+= ((PutnickiVagon)vag).getBrojSedista(); }

U osenčenom segmentu, prvo se instancira iterator iter metodom iterator() dinamičkog niza vagoni objekta voz, a zatim se vrši redosledna obrada. Prilikom korišćenja iteratora treba imati na umu da posle završenog prolaza iterator više nije upotrebljiv. Drugim rečima, iterator treba instancirati metodom iterator() pre svake obrade!

8. Stringovi, omotači i kolekcije



217

Važna napomena: ovaj segment izgledao bi identično i ako bismo vagone smestili u drugu vrstu kontejnera, npr. LinkedList, što i jeste suština postojanja iteratora!

U javi postoji još jedan interfejs za iteriranje sa čudnim nazivom Enumeration<E>. Ima svega dve metode, hasMoreElements i nextElement, koje u potpunosti odgovaraju metodama redom hasNext i next interfejsa Iterator. Ovaj interfejs je stara verzija, koja se održava zbog kompatibilnosti sa starijim verzijama jave. Instancira se metodom elements() koja takođe u potpunosti odgovara metodi iterator(). Nalazi se u paketu java.util. Interfejs Enumeration<E> boolean

hasMoreElements()

E

nextElement()

Vraća true sve dok ima još nepregledanih elemenata. Inače false. Vraća sledeći element

Primer 8.2. Umesto još jednog primera primene, proširićemo klasu ArrayList, tako što ćemo uključiti u nju iterator namenjen za iteriranje unatrag. Klasa koja predstavlja proširenje nosiće naziv EnhancedArrayList i biće, naravno, izvedena iz klase ArrayList. java.util::ArrayList

<E>

<E>

EnhancedArrayList

<E>

< > java.util::Iterator

< >

+Iterator<E> reverseIterator()

Slika 8.4.

PReverseIterator

Iterator se može opercionalizovati anonimnom klasom73 (standardna izvedba) ili unutrašnjom klasom. Ilustracije radi, pokazaćemo obe varijante. Anonimna klasa instancira se pozivanjem metode revereseIterator, a unutrašnja klasa sa nazivom PReverseIterator instancira se metodom reverseInnerIterator. U klasi PReverseIterator treba uočiti kvalifikovanje spoljnom klasom pri operacionalizaciji metode remove() koja postoji i u spoljašnjoj i u unutrašnjoj klasi. Takođe zapaziti da se kvalifikovanje mora izvršiti već ako se metode poklapaju po imenu: preklapanje metoda ne važi, osim ako unutrašnja klasa ne nasleđuje spoljašnju! EnhancedArrayList.java //Klasa ArrayList pojacana iteratorom unatrag import java.util.*; public class EnhancedArrayList<E> extends ArrayList<E> { //Konstruktori public EnhancedArrayList() { super(); } public EnhancedArrayList(Collection<E> c) { super(c); } public EnhancedArrayList(int initialCapacity) { super(initialCapacity); } //Realizacija iteratora preko anonimne klase public Iterator<E> reverseIterator() { 73

videti poglavlje 7, odeljak 7.5.1

8. Stringovi, omotači i kolekcije

218

return new Iterator<E>() { int current = size()-1; public boolean hasNext() { return current>-1; } public E next() { if(current<0) return null; else return get(current--); } public void remove() { if(size()==0) return; EnhancedArrayList.this.remove(current+1); } }; } public Iterator<E> reverseInnerIterator() { return new PReverseIterator(); } //Realizacija iteratora preko unutrasnje klase private class PReverseIterator implements Iterator<E> { private int current; public PReverseIterator() { current= size()-1; } public boolean hasNext() { return current>-1; } public E next() { if(current<0) return null; else return get(current--); poziv verzije remove iz spoljne klase } public void remove() { if(size()==0) return; EnhancedArrayList.this.remove(current+1); } } }

Evo i jednostavnog primera primene: import java.util.*; public class Main { public static void main(String args[]) { EnhancedArrayList ev = new EnhancedArrayList (); int elem; //Formiranje niza ev.add(1); ev.add(2); ev.add(3); ev.add(4); ev.add(5); //Iteriranje unapred System.out.println("ITERIRANJE UNAPRED"); for(int el:ev) System.out.println(el);

8. Stringovi, omotači i kolekcije

219

//Iteriranje unatrag pomocu iteratora reverseIterator() System.out.println("\nITERIRANJE UNATRAG (anonimna klasa)"); Iterator revIter = ev.reverseIterator(); while(revIter.hasNext()) { elem= revIter.next(); System.out.println(elem); } //Iteriranje unatrag pomocu iteratora reverseInnerIterator() System.out.println("\nITERIRANJE UNATRAG (unutrasnja klasa)"); Iterator revInnerIter = ev.reverseInnerIterator(); while(revInnerIter.hasNext()) { elem= revInnerIter.next(); System.out.println(elem); } //Iteriranje unatrag pomocu reverseIterator sa brisanjem System.out.println("\nITERIRANJE UNATRAG SA BRISANJEM"); revIter = ev.reverseIterator(); while(revIter.hasNext()) { elem= revIter.next(); System.out.println(elem); revIter.remove(); } //Pokusaj iteriranja kroz prazan niz System.out.println("\nPOKUSAJ ITERIRANJA KROZ PRAZAN NIZ"); revIter = ev.reverseIterator(); if(!revIter.hasNext()) System.out.println("Niz je prazan."); else while(revIter.hasNext()) { elem= revIter.next(); System.out.println(elem); } } }

8.3.3. Klasa LinkedList Klasa LinkedList je realizacija strukture podataka poznate pod nazivom dvostruko spregnuta lista. Radi se o listi kod koje su susedni elementi spregnuti u oba smera, te otud i alternativni naziv simetrična lista. Logička struktura ovakve liste prikazana je na slici 8.5.

Slika 8.5. Realizacija dvostruko spregnute liste odlikuje se postojanjem dva pokazivača (tj. reference u javi): jedan pokazivač pokazuje na desni susedni element, a drugi na levi. Sami pak elementi nalaze se na proizvoljnim lokacijama na hipu (nisu susedni kao kod dinamičkog niza), slika 8.6.

8. Stringovi, omotači i kolekcije

220

Slika 8.6. Osnovna osobina svake liste jeste fleksibilnost. Dozvoljen je pristup svakom elementu, može se ukloniti bilo koji element i dodati na svakom mestu. Pošto i dinamički niz (tj. objekat klase ArrayList u javi) ima iste osobine, postavlja se pitanje upoređenja ove dve klase. Kada je u pitanju pristup, dinamički niz je u prednosti pred listom: operacija se odvija znatno brže jer se ostvaruje indeksiranjem, tj. preliminarnim računanjem adrese i pristupom u jednom pokušaju. Kod liste stvar stoji drukčije zato što redni broj elementa nije ni u kakvoj korelaciji sa njegovom adresom. uklanjanje

dodavanje

Slika 8.7. Osnovni algoritam pristupa elementu na poziciji i jeste pristup prvom, zatim čitanje adrese drugog iz sadržaja prvog, pa na isti način pristup trećem itd. Dvostruko spregnuta lista omogućuje izvesno ubrzanje s obzirom na dvosmerno kretanje. Naime, ako je vrednost i relativno mala (element blizak početku) lista se pregleda od početka. Ako je blizak kraju lista se pregleda od kraja, unatrag. Konačno, ako je i blisko rednom broju elementa koji je poslednji referenciran, kreće se od njega. Obrnuto, uklanjanje i dodavanje u listi brže se izvode nego kod dinamičkog niza jer nema potrebe za premeštanjem elemenata niti za ma kakvim drugim rekonfigurisanjem. Uklanjanje odn. dodavanje vrše se prostom izmenom vrednosti pokazivača (referenci), pošto se prethodno pronađe element za uklanjanje, odn. mesto dodavanja. Šema uklanjanjadodavanja prikazana je na slici 8.7. Glavne metode u klasi LinkedList iste su kao i u klasi ArrayList. Evo spiska najvažnijih: Klasa LinkedList<E> LinkedList() LinkedList(Collection col) int

size()

boolean

isEmpty()

boolean

contains(Object el)

E

get(int i)

E

getFirst()

E

getLast()

int

indexOf(Object el)

Kreira praznu listu Kreira listu iz objekta col (videti klasu ArrayList) Vraća broj elemenata u listi Da li je prazna Provera da li lista sadrži objekat el. Proverava se sadržaj (ne referenca!) Vraća i-ti element liste Vraća prvi (krajnji levi) element liste Vraća poslednji (krajnji desni) element liste Vraća prvi element sa sadržajem kao el

8. Stringovi, omotači i kolekcije

boolean

add(E el)

void

add(int i,E el)

void

addFirst(E el)

void

addLast(E el)

E

remove(int i)

boolean

remove(Object el)

E

removeFirst()

E

remove()

E

removeLast()

void

clear()

E

set(int i,E el)

Iterator<E>

iterator()

Object[]

toArray()

221

Dodavanje el na (desni) kraj liste Dodavanje el na mesto i Dodavanje el na početak liste Dodavanje el na kraj liste Uklanja i-ti element i vraća ga kao rezultat Uklanja prvi element koji ima isti sadržaj kao el Uklanja prvi i vraća ga isto Uklanja poslednji i vraća ga Pražnjenje liste Zamenjuje i-ti element elementom el Iterator Konverzija u niz

Lista (LinkedList) i dinamički niz (ArrayList) se praktično jednako ponašaju i koriste se na isti način, tako da se postavlja logično pitanje kada upotrebiti koju od dve strukture. Odgovor možemo sažeti u sledeći spisak:    

operacije dodavanja i uklanjanja brže su kod liste pristup prema poziciji (indeksu) brži je kod dinamičkog niza niz se može prepuniti (overflow) što zahteva rekonfigurisanje; lista se ne može prepuniti redosledna obrada (iteriranje) ima približno istu performansu.

Primer 8.3. U svim kontejnerskim klasama postoji konstruktor ime(Collection c), gde je interfejs Collection implementiran od svih kontejnerskih klasa. Prava svrha ovog konstruktora jeste konverzija iz jedne kontejnerske klase u drugu. Evo jednog primera konverzije iz klase EnhancedArrayList u klasu LinkedList: import java.util.*; public class Main { public static void main(String args[]) { EnhancedArrayList ealist = new EnhancedArrayList (); //Formiranje niza for(int i=1;i<=5;i++) ealist.add(i); //Iteriranje dinamickog niza unapred System.out.println("ITERIRANJE UNAPRED"); for(int el:ealist) System.out.println(el); //Konverzija dinamickog niza u listu LinkedList symmList = new LinkedList (ealist); System.out.println("\nDINAMICKI NIZ KONVERTOVAN U LISTU."+ "Sadrzaj liste:"); for(int el:symmList) System.out.println(el); } }

Primer 8.4. Jedan od važnih postupaka vezan za mnoge kontejnerske klase jeste redosledna obrada elemenata po ključu. Prvo, ovaj način obrade podrazumeva da u sadržaju elemenata

8. Stringovi, omotači i kolekcije

postoji deo koji je jedinstven za svaki element prema ključu podrazumeva pristup elementima ključa (recimo rastuća vrednost). Upravo ovaj obzirom na spor pristup prema poziciji. Da bi njihov skup mora ispuniti jedan uslov: 

222

i koji nosi naziv ključ. Redosledna obrada po nekom redosledu vezanom za vrednost način obrade karakterističan je za listu, s se omogućila redosledna obrada po ključu

ključevi moraju biti međusobno uporedivi da bi se lista održavala sortiranom.

U ovom primeru napravićemo listu u koju se upisuju elementi karakterisani ključem, pri čemu se lista održava stalno sortiranom po rastućoj vrednosti ključa. U klasi neće postojati posebna metoda za sortiranje, nego će operacija dodavanja elementa add biti podešena tako da se sortiranost postiže dinamički i održava stalno, tokom životnog veka liste. Da bi neki objekat mogao da uđe u sortiranu listu treba da zadovolji jedan uslov: 

element sortirane liste mora imati ključ.

Ovaj uslov obezbeđujemo tako što klasa kojoj pripadaju elementi sortirane liste implementira generički interfejs HasKey . Pri tom, nije dovoljno da element samo ima ključ - mora postojati način da se ključ očita, a takođe vrednosti ključa moraju biti međusobno uporedive. Ovo se postiže uvrštavanjem u interfejs metode getKey() koja mora da bude operacionalizovana u klasi elemenata (u suprotnom biće javljena greška). Konačno, vrednost koju vraća metoda getKey() je tipa Comparable . Ovaj tip je, u stvari, standardni interfejs što osigurava postojanje metode compareTo(KEY key) u okviru klase kojoj pripada sam ključ, a koja vrši komparaciju s drugim ključevima. Ako je ključ sam po sebi neki od omotača ili je String, metoda compareTo je već prisutna. Ako pak nije (ređi slučaj), moramo je uvrstiti u klasu kojoj pripada ključ. Dakle, na ovaj način osigurano je da metode getKey i compareTo neizostavno postoje. Interfejs HasKey ima sledeći izgled: HasKey .java public interface HasKey { Comparable getKey(); }

Samu listu moramo pripremiti tako da zadovolji sledeće uslove: 1. sme da prihvati samo objekte koji imaju ključ. 2. sme da ponudi samo metode koje se baziraju na ključu i nikako na poziciji, jer korišćenje pozicije, recimo za dodavanje, može da naruši stanje sortiranosti liste. I ove uslove obezbeđujemo interfejsom kroz kojim pristupamo samoj klasi. Interfejs ćemo nazvati SortedList gde je KEY tip ključa, a E tip elementa liste.: SortedList .java //Interfejs sortirane liste import java.util.Iterator; public interface SortedList { E get(Comparable key); int size(); boolean isEmpty(); boolean add(HasKey el); E remove(Comparable key); void clear(); Iterator<E> iterator(); }

8. Stringovi, omotači i kolekcije

223

Sama sortirana lista, sa imenom PSortedList , napravljena je tako da generiše sortiranu listu čiji su elementi tipa E, a ključevi tipa KEY. Jedini način da se kreira sortirana lista je statička metoda PSortedList.makeSortedList koja odmah uspostavlja vezu sa interfejsom SortedList, tako da je taj interfejs jedini način za njeno korišćenje. Uočimo da je konstruktor klase PSortedList zatvoren, da bi se sprečila greška pri kreiranju. Dijagram klasa prikazan je na slici 8.8. < > SortedList

<E>

java.util::LinkedList < > HasKey

< > java.util::Comparable

<<use>> PSortedList

1

Slika 8.8.

(element liste)

(ključ)

*

PSortedList .java //Lista sortirana po kljucu import java.util.LinkedList; import java.util.Iterator; public class PSortedList extends LinkedList<E> implements SortedList { //Konstrukcija sortirane liste public static SortedList makeSortedList() { return new PSortedList (); } //Privatni konstruktor private PSortedList() { super(); } //Ocitavanje po kljucu public E get(Comparable key) { HasKey elem; Iterator<E> iter = iterator(); while(iter.hasNext()) { elem= (HasKey )iter.next(); if(key.compareTo((KEY)elem.getKey())==0) return (E)elem; } return null; } //Dodavanje po kljucu public boolean add(HasKey el) { HasKey elem; if(isEmpty()){addFirst((E)el); return true;} Iterator<E> iter = iterator(); for(int index=0;iter.hasNext();index++) { elem= (HasKey )iter.next(); if(el.getKey().compareTo((KEY)elem.getKey())==0) return false; else if(el.getKey().compareTo((KEY)elem.getKey())<0) {

8. Stringovi, omotači i kolekcije

224

add(index,(E)el); return true;} } addLast((E)el); return true; } //Uklanjanje po kljucu public E remove(Comparable key) { HasKey elem; Iterator<E> iter = iterator(); for(int index=0;iter.hasNext();index++) { elem= (HasKey )iter.next(); if(key.compareTo((KEY)elem.getKey())==0) return remove(index); else if(key.compareTo((KEY)elem.getKey())<0) return null; } return null; } }

Za upoređivanje ključeva koristi se metoda compareTo(T ob), gde je T generički parametar interfejsa Comparable . Metoda mora biti operacionalizovana tako da postoji u klasi kojoj pripada ključ. Inače, ona poredi objekat što implementira interfejs Comparable sa objektom ob. Ako je objekat preko kojeg je aktivirana metoda manji od ob, vraća se rezultat -1, ako su jednaki vrednost 0 i ako je veći rezultat 1. Umesto naredbe for-each konsekventno se koristi iterator, da bi bila omogućena primena metode remove(index) u metodi remove. Priprema za korišćenje sortirane liste je, u stvari, vrlo jednostavna. Treba formirati klasu kojoj će pripadati elementi liste i to sa sledećim osobinama: 1. klasa mora implementirati interfejs HasKey<TipKljuca>, gde je TipKljuca generički argument (konkretna klasa) kojoj pripadaju ključevi, pri čemu taj tip mora da implementira interfejs Comparable; napominjemo da svi numerički tipovi (Integer, Double, itd.) kao i klasa String tu osobinu već imaju 2. klasa mora sadržati operacionalizovanu metodu public TipKljuca getKey() 3. polje koje igra ulogu ključa mora implementirati interfejs Comparable, što znači da ima operacionalizovanu metodu compareTo(). Metoda getKey() vraća vrednost tog polja. Napominjemo da je klasa tako realizovana da bez gornjih osobina neće moći da se prevede, tako da nema opasnosti od grešaka. Sortirana lista konstruiše se naredbom SortedList imeListe = PSortedList.makeSortedList();

Kao primer, sastavićemo klasu Student sa elementarnim podacima o studentu. Student.java //Klasa koja predstavlja tip elementa liste public class Student implements HasKey { private Integer brojIndeksa; private String prezime, ime; public Student(int brojIndeksa,String prezime,String ime) { this.brojIndeksa = new Integer(brojIndeksa); this.prezime= prezime; this.ime= ime; } public Integer getKey() { return brojIndeksa;

8. Stringovi, omotači i kolekcije

225

} public int getBrojIndeksa() { return brojIndeksa; } public String getPrezime() { return prezime; } public String getIme() { return ime; } }

Ulogu ključa igra polje brojIndeksa koje je tipa omotača Integer. Ovaj standardni omotač implementira interfejs Comparable, tako da nije potrebno operacionalizovati metodu compareTo, jer već postoji. U suprotnom, morali bismo sačiniti posebnu klasu za ključ, implementirati interfejs Comparable i realizovati metodu compareTo. Usput, verovatnoća za to je mala jer, kako smo već rekli, većina klasa kandidata za ključeve već implementira Comparable tj. sadrži metodu compareTo. U klasi Student mora da postoji operacionalizovana metoda getKey() jer klasa implementira interfejs HasKey. Metoda vraća objekat brojIndeksa. Na kraju navodimo i samoobjašnjavajući primer primene sortirane liste čiji su elementi iz klase Student. import java.util.Iterator; public class Main { public static void showList(String txt, SortedList lst) { Student st; System.out.println(txt); Iterator<Student> iter = lst.iterator(); while(iter.hasNext()) { st= iter.next(); System.out.println(st.getKey()+" "+st.getPrezime()+ " "+st.getIme()); } } public static void showStudent(String txt,Student st) { System.out.println(txt); if(st!=null) System.out.println(st.getKey()+ " "+st.getPrezime()+" "+st.getIme()); else System.out.println("Nema takvog elementa"); } public static void main(String args[]) { SortedList spisakStudenata = PSortedList.makeSortedList(); Student st; //Formiranje liste spisakStudenata.add(new Student(4,"Mikic","Jovan")); spisakStudenata.add(new Student(1,"Jocic","Petar"));

8. Stringovi, omotači i kolekcije

226

spisakStudenata.add(new Student(3,"Slavic","Slavko")); spisakStudenata.add(new Student(5,"Nikolic","Nikola")); spisakStudenata.add(new Student(2,"Pavic","Milan")); showList("FORMIRANA LISTA STUDENATA",spisakStudenata); st= spisakStudenata.remove(5); showList("\nUKLONJEN KLJUC 5",spisakStudenata); st= new Student(5,"Milanovic","Milan"); spisakStudenata.add(st); showList("\nDODAT KLJUC 5",spisakStudenata); st= new Student(5,"Stevic","Steva"); System.out.println("\nPOKUSAJ DODAVANJA KLJUCA 5"); if(!spisakStudenata.add(st)) System.out.println("Kljuc vec postoji"); st= (Student)spisakStudenata.get(3); showStudent("\nDOHVATANJE KLJUCA 3",st); st= (Student)spisakStudenata.get(1); showStudent("\nDOHVATANJE KLJUCA 1",st); st= (Student)spisakStudenata.get(5); showStudent("\nDOHVATANJE KLJUCA 5",st); st= (Student)spisakStudenata.get(0); showStudent("\nDOHVATANJE KLJUCA 0",st); st= (Student)spisakStudenata.get(10); showStudent("\nDOHVATANJE KLJUCA 10",st); System.out.println("\nPOKUSAJ UKLANJANJA KLJUCA -1"); if(spisakStudenata.remove(-1)==null) System.out.println("Kljuca nema"); System.out.println("\nPOKUSAJ UKLANJANJA KLJUCA 20"); if(spisakStudenata.remove(20)==null) System.out.println("Kljuca nema"); }

} 8.3.4. Klasa HashMap U prethodnom primeru videli smo kako se ostvaruje glavni zadatak liste - redosledna obrada po ključu. Drugi osnovni oblik obrade po ključu je tzv. direktna obrada gde se elementima kontejnera (tj. strukture podataka) pristupa takođe preko ključa, ali u proizvoljnom redosledu. U opštem slučaju lista nije naročito pogodna za ovakvu vrstu obrade. Prosečan broj pokušaja pri pronalaženju elementa sa proizvoljnom vrednošću ključa jednak je približno n/2 gde je n broj elemenata u listi74. Drugim rečima, da bi se pronašao element sa proizvoljnim ključem (koji postoji u listi) potrebno je pregledati pola liste, što je najčešće premnogo. Heš (engl. "hash") ili rasute tabele predstavljaju odgovor na zahtev za smanjenjem prosečnog broja pokušaja. Ideja je jednostavna: neka je memorijski prostor za smeštanje elemenata realizovan sekvencijalno, kao niz od C sukcesivnih memorijskih lokacija sa relativnom adresama (pozicijama) 0,1,...,C-1. Neka je potrebno upisati element e sa ključem ke. Mesto upisa (relativnu adresu) odredićemo direktnom transformacijom ključa putem neke transformacione funkcije h tako da bude 74

Tačna vrednost prosečnog broja pokušaja iznosi (n+1)/2 pod uslovom da je verovatnoća zahteva za pristup ista za sve elemente i iznosi 1/n.

8. Stringovi, omotači i kolekcije

227

a = h(ke). gde je a{0,...,C-1} relativna adresa lokacije. Kasnije, kada je potrebno pristupiti elementu e, adresa se određuje iz ključa ke istom formulom. Dakle, u ovom, idealnom, slučaju relativna adresa za pristup elementu preko ključa dobija se posle primene transformacije h u jednom jedinom pokušaju. U realnim situacijama, međutim, postavlja se ozbiljno pitanje: kako treba da izgleda transformaciona funkcija i da li uopšte postoji? U opštem slučaju, odgovor je, nažalost - ne postoji. Čak ni pokušaj da se numerički ekvivalent ključa upotrebi kao adresa, u opštem slučaju ne uspeva jer te vrednosti mogu biti prevelike. Ako bismo, na primer, (trinaestocifreni) matični broj građana pokušali da upotrebimo kao adresu bilo bi neophodno zauzeti približno C=1013 lokacija koje bi pokrile sve potencijalne vrednosti ključeva, što je naravno besmisleno. Rešenje je pronađeno u upotrebi generatora pseudoslučajnih brojeva. Postupak se sastoji u tome da se na bazi vrednosti ključa ke generiše pseudoslučajan broj u rasponu 0,...,C1 i taj broj upotrebi kao adresa za upis-čitanje elementa. Transformacija h koja se zasniva na generisanju pseudoslučajnog broja nosi naziv probabilistička transformacija ključa u adresu ili heširanje (engl. "hashing") i obuhvata povelik broj različitih metoda. Probabilistička transformacija odvija se u tri koraka: 1. oformiti numerički ekvivalent ključa, ako ključ nije numerički (npr. ako je ključ string). 2. na bazi numeričkog ekvivalenta generisati pseudoslučajan broj. 3. ako generisani broj nije u opsegu 0..C-1 prevesti ga u taj opseg običnom linearnom transformacijom. Neka je num(ke) numerički ekvivalent ključa. Jedna od brojnih metoda za generisanje pseudoslučajnog broja na bazi vrednosti num(ke) jeste primena ostataka pri deljenju kojom se adresa a{0,...,C-1} dobija kao a = num(ke) (mod C) tj. h(ke)  num(ke) (mod C). Odmah napominjemo da ovo nije jedini postupak i da smo ga naveli isključivo iz ilustrativnih razloga. Probabilistička transformacija ključa u adresu ima dve osnovne karakteristike. Prvo, uvek zavisi od veličine C tj. od broja lokacija, što znači da se C bira unapred i ne može se menjati bez kompletne rekonfiguracije tabele. Drugo, ne postoji nikakva garancija da će različiti ključevi generisati različite adrese. Naprotiv, situacija u kojoj dva nejednaka ključa generišu istu adresu je sasvim normalna, tako da i sama pojava ima poseban naziv - kolizija ključeva. Elementi čiji ključevi generišu istu adresu nose naziv sinonimi. Svaka heš tabela mora biti snabdevena mehanizmom za razrešavanje kolizije ključeva, tj. metodom za rukovanje sinonimima, koja će obezbediti da element čiji je sinonim već upisan u tabelu, dobije novo mesto. Za ovaj problem postoji niz rešenja, a jedno od najpoznatijih pruža tzv. metoda linearnog traženja (sondiranja). Ideja je jednostavna: ako je lokacija sa adresom a u koju treba upisati element zauzeta, pokušava se sa lokacijom a+1 (sledećom po redu), pa ako ne ide sa lokacijom a+2 itd. Ako je tabela zauzeta sve do kraja nastavlja se u krug, od lokacije sa adresom 0, pa 1, zatim 2 itd. Izraženo matematičkim jezikom, određivanje lokacije za upis elementa sa ključem ke odvija se izračunavanjem adresa a0, a1,... po formulama a0 = h(ke) ai+1 = (ai+1) (mod C) i=0,1,2...

8. Stringovi, omotači i kolekcije

228

sve dok se ne pronađe lokacija koja je slobodna. Naravno, ako se pregleda cela tabela i ne nađe mesto, to znači prosto, da je tabela popunjena i da se mora rekonfigurisati. Poboljšana varijanta linearnog traženja jeste takođe odavno poznata metoda tzv. slučajnog traženja u kojoj se mesto za upis ne traži na sledećoj lokaciji nego na lokaciji udaljenoj za x mesta, gde se x dobija još jednom probabilističkom transformacijom, tzv. sekundarnom transformacijom. Ako osnovnu transformaciju koja se u ovom slučaju naziva primarnom, obeležimo sa h0, a sekundarnu sa h1, postupak izgleda ovako: a0 = h0(ke) ai+1 = (ai+x) (mod C) i=0,1,2... gde je x=h1(ke). Rukovanje sinonimima ovim metodama prikazano je na slici 8.9 (zauzete lokacije su šrafirane). ke

h

e

ke

h1

h0

e Slika 8.9. Prethodna razmatranja ne odnose se samo na javu, nego na organizaciju heš tabela uopšte. Generička klasa HashMap (starija verzija nosi naziv Hashtable) realizovana je tako da programera ne interesuje ni način za probabilističku transformaciju niti način za rukovanje sinonimima, jer je sve inkapsulirano u klasu i regulisano odgovarajućim metodama. Za rukovanje heš tabelom, java predviđa dva parametra: kapacitet i tzv. faktor popunjenosti. Faktor popunjenosti je prosto odnos između najvećeg dozvoljenog broja elemenata i kapaciteta tabele i kreće se teorijski od 0.0 do 1.0 (podrazumevana vrednost je 0.75). Kada odnos stvarnog broja elemenata i kapaciteta pređe ovu vrednost, dolazi do relativno dugotrajne rekonfiguracije u kojoj se povećava kapacitet, a zatim se postojeći elementi prepišu u uvećanu tabelu. Elementi heš tabele u javi dele se na dva dela: jedan, konvencionalno nazvan key, predstavlja ključ, dok drugi sa nazivom value sadrži sve ostale podatke što pripadaju elementu, slika 8.10. Generički parametri klase su K (tip ključa key) i V (tip vrednosti value), tako da je naziv generičke klase HashMap

key

value

Slika 8.10. Neka je data instanca hashT klase HashMap oblika HashMap hashT = new HashMap ();

8. Stringovi, omotači i kolekcije

229

gde su, sada, AK i AV konkretne klase koje predstavljaju generičke argumente. Neka su key i value dva objekta koji zajedno sačinjavaju element što ga treba upisati u heš tabelu. Upis se vrši naredbom hashT.put(key,value);

Upis se izvodi tako što se izvrši transformacija objekta key u adresu unutar heš tabele, po šemi koju smo prikazali u prethodnom delu odeljka. No, da bi transformacija bila izvodljiva, neophodno je da klasa kojoj pripada objekat key raspolaže metodom int hashCode()

koja se aktivira implicitno pri pozivu metode put. Ovo, inače, ne predstavlja poseban problem jer su sve javine klase već snabdevene ovom metodom (definisana je u klasi Object!), tako da je programer skoro uvek oslobođen brige oko transformacije. Čitanje elementa vrši se operacijom hashT.get(key)

gde metoda get vraća deo value koji pripada ključu key ili null ako element sa takvim ključem ne postoji u tabeli. Metoda get vraća tip V, tako da nije potrebno vršiti kast u stvarnu klasu kojoj pripada value. Prirodno, prilikom dohvatanja value preko ključa key opet se implicitno aktivira transformacija hashCode(). Sledi spisak nekoliko najvažnijih metoda klase HashMap: Klasa HashMap HashMap() HashMap(int capacity) HashMap(int capacity, float q) V

put(K key,V value)

V

get(Object key)

V

remove(Object key)

void

clear()

boolean

containsKey(Object key)

boolean

containsValue(Object value)

boolean

isEmpty()

int

size()

Kreiranje tabele inicijalnog kapaciteta 11 i faktora popunjenosti 0.75 Kreiranje tabele inicijalnog kapaciteta capacity i faktora popunjenosti 0.75 Kreiranje tabele inicijalnog kapaciteta capacity i faktora popunjenosti q Upisivanje elementa sa ključem key u tabelu. Ako je takav ključ već postojao vraća se stara vrednost value Vraća value za zadati ključ key. Ako ne postoji, vraća se null. Uklanjanje elementa sa ključem key. Vraća uklonjenu vrednost value ili null u slučaju neuspeha. Pražnjenje tabele Provera da li postoji element sa ključem key Provera da li postoji element sa sadržajem value Provera da li je tabela prazna Veličina tabele izražena u broju ključeva

Iako joj to nije osnovna namena, heš tabela ima mogućnost iteriranja, čak na nekoliko načina. Može se iterirati preko ključeva, preko sadržaja i preko celih elemenata i može se iterirati pomoću for-each ciklusa ili preko iteratora (ovo poslednje ako je potrebno uklanjati elemente). Osnovu za iteriranje preko ključeva omogućuje metoda keySet() tipa Set gde je Set generički interfejs što realizuje tip skupa (videti u dokumentaciji jave). Pošto ovaj interfejs implementira tip Collection, odgovarajuća klasa ima iterator, a dozvoljava i primenu naredbe for-each. Iteriranje preko sadržaja omogućuje metoda values() koja direktno vraća tip

8. Stringovi, omotači i kolekcije

230

Collection i realizuje kolekciju sa elementima što čine sadržaj. U primeru koji sledi prikazani su načini za iteriranje pomoću naredbe for-each. Primer 8.5. Kao prvi primer, demonstriraćemo neposrednu primenu klase HashMap za izradu jednostavne knjige inventara. Stavke su opisane ključem tipa Integer koji predstavlja šifru inventarske jedinice i naziva (ormar, sto, stolica itd.) tipa String. Pošto je svrha primera da se prikaže tehnika primene heš tabele, nećemo praviti posebnu klasu za to, nego ćemo sve smestiti u demonstracioni program. U programu se prvo formira inventarska knjiga primenom metode put, zatim se prikazuje direktan pristup metodom get i konačno se ilustruje iteriranje kroz tabelu na bazi iteratora keys(). import java.util.*; class Inventar { public static void main(String args[]) { HashMap inventKnjiga = new HashMap (); String naziv; //Formiranje knjige inventara inventKnjiga.put(100,"sto"); inventKnjiga.put(300,"ormar"); inventKnjiga.put(301,"ormar"); inventKnjiga.put(200,"stolica"); inventKnjiga.put(201,"stolica"); inventKnjiga.put(202,"stolica"); inventKnjiga.put(203,"stolica"); //Izvlacenje jednog sloga iz tabele System.out.println("USPESNO TRAZENJE PO KLJUCU"); naziv= inventKnjiga.get(100); if(naziv != null) System.out.println(100+" "+naziv); System.out.println("\nNEUSPESNO TRAZENJE PO KLJUCU"); naziv= inventKnjiga.get(101); if(naziv != null) System.out.println(naziv); else System.out.println("Element sa kljucem "+101+ " nije nadjen."); //Prikaz knjige inventara po kljucevima System.out.println("\nKNJIGA INVENTARA - pregled po kljucevima"); for(Integer key:inventKnjiga.keySet()) System.out.println(key+" "+inventKnjiga.get(key)); //Prikaz knjige inventara po sadrzaju System.out.println("\nKNJIGA INVENTARA - pregled po sadrzaju"); for(String value:inventKnjiga.values()) System.out.println(value); } }

Primer 8.6. Formiraćemo klasu PhoneBook što predstavlja telefonski imenik, pri čemu ćemo obezbediti da jedna osoba može da ima više telefonskih brojeva. Prvo, stavka telefonskog imenika sastoji se od prezimena i imena (ili nadimka, svejedno) name tipa String i dinamičkog niza phones pridruženih telefonskih brojeva, koji su opet tipa String. Ulogu ključa igra name.

8. Stringovi, omotači i kolekcije

Peric Mladen name

021 333 4444

231

064 23 38 112

phones

ključ

Slika 8.11. Sama klasa PhoneBook ima dva polja: string owner sa imenom vlasnika imenika i heš tabelu entries namenjenu za upis stavki koje su, sa svoje strane, dinamički nizovi telefonskih brojeva. Metode klase PhoneBook možemo razvrstati u dve grupe: prvu čine metode nivoa imenika. Drugu grupu metoda čine metode vezane samo za brojeve telefona. Metode koje manipulišu celim imenikom su sledeće:         

konstruktor koji upisuje ime vlasnika i prazan niz brojeva metoda getOwner() za očitavanje imena vlasnika metode size() i isEmpty() za određivanje broja stavki i proveru da li je imenik prazan addName(String name) za dodavanje nove stavke (imena) u imenik. Pripadajući niz brojeva telefona je prazan metoda removeName(String name) koja uklanja iz heš tabele ime i sve brojeve asocirane sa njim metoda clearAll() za brisanje svih stavki iz imenika bulova metoda containsName(String name) za proveru da li u imeniku postoji stavka sa imenom name metoda names() što vraća kolekciju ključeva (imena iz imenika) namenjenu iteriranju naredbom for-each iterator iterator() tipa Iterator<String > za iteriranje po ključevima.

Telefonskim brojevima vezanim za pojedinačne stavke u imeniku rukuje se sledećim metodama: 

 

 

metoda getPhones(String name) tipa ArrayList<String> je najvažnija metoda u klasi. Vraća sve brojeve telefona pridružene stavci sa imenom name i to u vidu dinamičkog niza stringova metoda addPhone(String name,String phone) služi za dodavanje novog telefonskog broja uz ime name. Ako nema imena dodaje se. Ako broj postoji ne dešava se ništa. metodom removePhone(String name,String phone) uklanja se telefonski broj phone iz stavke sa imenom name, Ako takvog broja nema, sve ostaje nepromenjeno, a metoda vraća odgovarajuću indikaciju. metodom clearPhones(String name) brišu se svi telefonski brojevi vezani za ime name. Ime ostaje. metoda names() predstavlja iterator tipa Enumeration. Iterira se po ključevima.

Sledi programski tekst klase PhoneBook i demonstracioni program. PhoneBook.java //Telefonski imenik realizovan kao hes tabela import java.util.*; public class PhoneBook { private String owner; private HashMap<String,ArrayList<String>> entries; //Konstruktor public PhoneBook(String owner) { this.owner= owner; entries= new HashMap<String,ArrayList<String>>();

8. Stringovi, omotači i kolekcije

} //Ocitavanje vlasnika imenika public String getOwner() { return owner; } //Prazan imenik? public boolean isEmpty() { return entries.isEmpty(); } //Broj stavki u imeniku public int size() { return entries.size(); } //Upis nove stavke //Ako je vec postojala stavka sa tim kljucem odustaje se public boolean addName(String name) { if(containsName(name)) return false; ArrayList<String> phones = new ArrayList<String>(); entries.put(name,phones); return true; } //Brisanje stavke public boolean removeName(String name) { return (entries.remove(name)!=null) ? true : false; } //Brisanje svih stavki public void clearAll() { entries.clear(); } //Da li postoji stavka? public boolean containsName(String name) { return entries.containsKey(name); } //Ocitavanje niza brojeva telefona na osnovu imena //Ako ime ne postoji vraca se null public ArrayList<String> getPhones(String name) { return entries.get(name); } //Dodavanje telefonskog broja (ako ne postoji) public boolean addPhone(String name,String phone) { if(!containsName(name)) addName(name); if(entries.get(name).contains(phone)) return false; entries.get(name).add(phone); return true; } //Brisanje telefonskog broja public boolean removePhone(String name,String phone) { return entries.get(name).remove(phone); } //Brisanje svih brojeva public void clearPhones(String name) { entries.get(name).clear();

232

8. Stringovi, omotači i kolekcije

233

} //Kolekcija brojeva za dato ime public Collection<String> names() { return entries.keySet(); } //Iterator public Iterator<String> iterator() { return entries.keySet().iterator(); } } public class Main { public static void showEntry(String txt,PhoneBook book,String name) { System.out.println(txt); if(!book.containsName(name)) { System.out.println("Nema takve stavke"); return; } System.out.print("IME: "+name+" BROJEVI: "); for(String number:book.getPhones(name)) System.out.print(number+" "); System.out.println(); } public static void main(String args[]) { PhoneBook imenik = new PhoneBook("Branislav Sekulic"); System.out.println("VLASNIK IMENIKA: "+imenik.getOwner()); //Upis stavke u imenik imenik.addName("Jovic Jova"); imenik.addPhone("Jovic Jova","1111"); imenik.addPhone("Jovic Jova","1112"); imenik.addPhone("Jovic Jova","1113"); showEntry("\nUnet Jovic Jova.",imenik,"Jovic Jova"); //Brisanje telefona 1113 imenik.removePhone("Jovic Jova","1113"); showEntry("\nObrisan telefon 1113.",imenik,"Jovic Jova"); //Upis novih stavki u imenik imenik.addPhone("Ilic Ilija","2222"); imenik.addPhone("Ilic Ilija","2223"); showEntry("\nUnet Ilic Ilija.",imenik,"Ilic Ilija"); imenik.addPhone("Peric Pera","3333"); showEntry("\nUnet Peric Pera.",imenik,"Peric Pera"); imenik.addPhone("Mikic Mika","4444"); imenik.addPhone("Mikic Mika","4445"); showEntry("\nUnet Mikic Mika.",imenik,"Mikic Mika"); //Citanje nepostojece stavke showEntry("\nCitanje (nepostojeceg) Vladic Vlade.", imenik,"Vladic Vlada"); //Brisanje stavke imenik.removeName("Ilic Ilija"); showEntry("\nObrisan Ilic Ilija.",imenik,"Ilic Ilija");

8. Stringovi, omotači i kolekcije

234

//Iteriranje System.out.println("\n\nSADRZAJ IMENIKA:"); for(String name:imenik.names()) showEntry("",imenik,name); } }

8.4. KLASA CLASS I RTTI Inkluzioni polimorfizam postoji u objektnom programiranju od samog početka: objekat neke klase može da se ponaša kao pripadnik matične klase, ali i kao pripadnik ma koje klase iz koje je matična klasa izvedena, neposredno ili posredno. Imajući u vidu činjenicu da je ponašanje objekta određeno njegovim tipom, možemo zaključiti da objekat u toku izvršenja programa može menjati tip, pri čemu ostaje instanca jedne te iste klase75 . Tim je zanimljivije što ustanovljavanje kojeg je tipa objekat čijom referencom (adresom) program manipuliše u datom trenutku, nije od naročitog značaja u programskim jezicima. Razlog za to je dinamičko povezivanje koje obezbeđuje da verzija (redefinisane) metode koja se poziva u nekom trenutku zavisi isključivo od objekta preko kojeg se metoda poziva, čime se garantuje da će se objekat, bez obzira koji mu je tip ponašati korektno. Dinamička identifikacija tipa ili Run Time Type Identification (RTTI) je skup javinih sredstava za identifikaciju tipa objekta u toku izvršenja programa. Nešto od takvih sredstava postoji i u paskalu, ali u dosta rudimentarnom obliku. Java raspolaže prilično dobro razrađenim repertoarom operacija i metoda namenjenih RTTI. Sa jednim operatorom smo se već upoznali u poglavlju 7, a to je relacioni operator instanceof. Podsetimo se, ako je ob referenca na objekat i K neka klasa, tada izraz ob instanceof K

ima vrednost true ako ob referencira instancu klase K ili neke od njenih potklasa. Osnovna namena operatora instanceof jeste bezbedna primena koercitivnog polimorfizma, tj. kasta iz bazne u izvedenu klasu (videti odeljak 7.1.3), te zato ovim operatorom ne možemo potpuno precizno ustanoviti klasu kojoj pripada objekat referenciran sa ob. Za ustanovljavanje matične klase datog objekta (i još za mnoge druge slične poslove) java nudi grupu metoda objedinjenih u specijalnu generičku finalnu klasu sa nazivom Class , koju neki nazivaju i metaklasom. Svakoj klasi koja učestvuje u nekom programu virtuelna mašina pridružuje po jedan objekat klase Class koji nosi naziv klase i sufiks .class. Dakle, prevođenje klase MyClass obuhvata i stvaranje objekta MyClass.class

koji sadrži podatke o klasi MyClass. Njegov tip je Class<MyClass> i nalazi se u datoteci sa bajt-kodom MyClass.class. Objektima klase Class najčešće rukujemo preko reference tipa Class koja označava da je generički argument nepoznat. Klasa Class ne može se instancirati. Postoje dva načina za dohvatanje podataka o nekoj klasi: direktni, bez učešća objekta klase i indirektni kod kojeg se podaci o matičnoj klasi dobijaju preko instance objekta. U oba slučaja cilj je isti: oformiti instancu klase Class koja odgovara datoj klasi. Posmatraćemo, opet, klasu MyClass. Direktno dohvatanje podataka o klasi obavlja se pomoću statičke metode iz klase Class static Class forName(String ime_klase)

što vraća objekat iz Class koji odgovara klasi za koju tražimo podatke. Na primer, referencom 75

razlika između klase i tipa vrlo je suptilna, predmet je diskusija i svodi se na to da tip određuje ponašanje, dok klasa predstavlja jedan od načina realizacije tipa (videti formalnu definiciju klase).

8. Stringovi, omotači i kolekcije

235

Class c = Class.forName("MyClass");

dohvatićemo objekat c koji opisuje klasu MyClass. Odmah napominjemo da metoda forName generiše tzv. izuzetak, tako da se pomenuta naredba mora uključiti u tzv. blok try (videti sledeće poglavlje). Noviji, takođe direktni, način dohvatanja podataka o klasi obavlja se posredstvom tzv. klasnih literala (engl. "class literals") koji nisu ništa drugo do svojevrsne konstante tipa Class. Klasni literali imaju oblik ImeKlase.class

Dakle, literal za MyClass je MyClass.class. Klasni literali prošireni su i na bazne tipove i nizove, a u posebnom obliku mogu se pročitati i iz omotačkih tipova. Za bazni tip npr. double, klasni literal je double.class, a slična situacija je i sa ostalim baznim tipovima. Konačno, klasni literal niza ima oblik tip[].class, recimo int[].class ili Character[].class. Literal važi u svim klasama, apstraktnim ili konkretnim, kao i u interfejsima. Naredba za formiranje objekta sa podacima o klasi, analogna naredbi sa metodom forName, jednostavnija je i ne zahteva pomenuti blok try: Class c

= MyClass.class;

Indirektni način dohvatanja podataka o klasi podrazumeva postojanje instance klase preko koje se pristupa odgovarajućem objektu iz Class. Sredstvo za to je metoda Class getClass()

koja vraća referencu na Class. Ako je myObj objekat iz klase MyClass tada se podaci o MyClass preko pomenutog objekta mogu dobiti naredbom Class c = myObj.getClass();

Metoda getClass definisana je u klasi Object pa, prema tome, postoji u svakoj klasi. Napominjemo da direktni i indirektni način nisu obavezno alternativni postupci za ostvarenje istog cilja. Naprotiv, oni se koriste simultano kada je potrebno ustanoviti matičnu klasu nekog objekta. Naime, za razliku od izraza myObj instanceof K

koji ima vrednost true ako je K matična klasa MyClass, ali i svaka klasa izvedena iz nje, izraz myObj.getClass().equals(K.class)

imaće vrednost true ako i samo ako K predstavlja MyClass. Za klase izvedene iz nje izraz ima vrednost false! Prema tome, ako hoćemo da proverimo da li myObj u datom trenutku referencira objekat iz klase MyClass i nijedne druge, u tu svrhu upotrebićemo logički izraz myObj.getClass().equals(MyClass.class)

Izdvojimo samo nekoliko najvažnijih od mnoštva metoda klase Class (oznaka obC odnosi se na objekat klase Class - uključujući i literale - na koji je primenjena metoda): Klasa Class static Class String

forName(String clsName) getName()

Vraća objekat tipa Class pridružen klasi sa imenom clsName Vraća ime klase kojoj je pridružen objekat obC

8. Stringovi, omotači i kolekcije

Package

236

getPackage()

Vraća paket u kojem se nalazi klasa pridružena obC Class getSuperClass() Vraća objekat koji se odnosi na baznu klasu obC boolean isArray() Vraća true ako se obC odnosi na niz boolean isInstance(Object ob) Vraća true ako je ob instanca klase obC boolean isInterface() Vraća true ako se obC odnosi na interfejs boolean isPrimitive() Vraća true ako se obC odnosi na primitivni (bazni) tip Kada je u pitanju RTTI, ovim metodama treba pridodati i operator instanceof, kao i metode getClass() i equals() iz klase Object. Inače, klasa Class raspolaže još priličnim brojem metoda koje služe za manipulisanje klasama čiji sadržaj nije unapred poznat (recimo, mogu se locirati sve metode, konstruktori, korišćene klase itd.). Ove metode su specifične i na njima se nećemo posebno zadržavati. Razmotrićemo sada način primene pomenutih metoda na RTTI. Za osnovu ilustracije upotrebićemo hijerarhiju geometrijskih figura u paketu figure sa kojom smo se već susretali u par navrata. Prikazana je na slici 8.12. Napravićemo, za početak, statičku metodu printClassInfo koja, na osnovu objekta c klase Class, prikazuje na ekranu ime klase, ime paketa i ime bazne klase (superklase). Metoda izgleda ovako: static void printClassInfo(String txt,Class c) { System.out.println(txt); System.out.println("Klasa: "+c.getName()); System.out.println("Paket: "+c.getPackage().getName()); System.out.println("Bazna klasa: "+ c.getSuperclass().getName()); } figure::Figura {abstract}

figure::Trougao

figure::PravougliTrougao

figure::Pravougaonik

figure::RavnostraniTrougao

figure::Krug

figure::Kvadrat

Slika 8.12. Direktno dohvatanje podataka o klasi, kako smo rekli, vrši se bez posredstva instance. Evo kako izgleda taj postupak za slučaj klase Pravougaonik (uočiti primenu klasnog literala Pravougaonik.class): //Direktno dohvatanje podataka o klasi Class c1= Pravougaonik.class; printClassInfo("DIREKTNO DOHVATANJE PODATAKA O KLASI",c1);

Po izvršenju ovog segmenta, na ekranu će se pojaviti sledeći izlaz: DIREKTNO DOHVATANJE PODATAKA O KLASI Klasa: figure.Pravougaonik Paket: figure Bazna klasa: figure.Figura

8. Stringovi, omotači i kolekcije

237

Indirektan pristup podacima o klasi vrši se preko njene instance. Ilustrovaćemo ovaj postupak na primeru klase Kvadrat čije ćemo podatke očitati preko instance kv: //Indirektno dohvatanje podataka o klasi Kvadrat kv = new Kvadrat(5); Class c2= kv.getClass(); printClassInfo("DOHVATANJE PODATAKA O KLASI PREKO INSTANCE",c2);

Ovaj segment produkovaće sledeći izlaz: DOHVATANJE PODATAKA O KLASI PREKO INSTANCE Klasa: figure.Kvadrat Paket: figure Bazna klasa: figure.Pravougaonik

Da bismo demonstrirali kako se koristi klasa Class za RTTI formiraćemo dinamički niz figNiz čiji su elementi definisani kao objekti klase Figura. Imajući u vidu hijerarhiju geometrijskih figura sa slike 8.12, lako uočavamo da elementi niza mogu pripadati ma kojoj klasi izvedenoj iz klase Figura76, i da se tačan tip elementa zna tek u trenutku njegovog upisivanja u niz. Sledeći segment će definisati dinamički niz i upisati u njega neke figure: ArrayList figNiz = new ArrayList (); figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new figNiz.add(new

Pravougaonik(1,3)); PravougliTrougao(5,7)); Kvadrat(1)); PravougliTrougao(3,5)); RavnostraniTrougao(10)); Kvadrat(2)); Krug(1)); Kvadrat(3)); Trougao(3,5,7)); Pravougaonik(2,5)); Kvadrat(4)); RavnostraniTrougao(2)); Krug(2)); Kvadrat(5)); Pravougaonik(3,5));

Sadržaj niza figNiz prikazuje se tako što se iteratorom for-each prođe kroz njega i metodom getClass() ekstrahuje klasa kojoj pripada element niza, da bi se potom metodom getName() primenjenom na ekstrahovanu klasu došlo do njenog imena: System.out.println("\nSADRZAJ NIZA FIGURA:"); for(Figura fig:figNiz) System.out.println(fig.getClass().getName());

Izvršenjem ovog segmenta na ekranu se dobija izlaz SADRZAJ NIZA FIGURA: figure.Pravougaonik figure.PravougliTrougao figure.Kvadrat figure.PravougliTrougao figure.RavnostraniTrougao figure.Kvadrat figure.Krug 76

Izuzimajući samu klasu Figura jer je apstraktna.

8. Stringovi, omotači i kolekcije

238

figure.Kvadrat figure.Trougao figure.Pravougaonik figure.Kvadrat figure.RavnostraniTrougao figure.Krug figure.Kvadrat figure.Pravougaonik

Prikažimo sada primenu RTTI. Prvo, definišimo segment int brSvihTroug = 0; for(Figura fig:figNiz) if(fig instanceof Trougao) brSvihTroug++; System.out.println("\nUkupan broj trouglova: "+brSvihTroug);

Ovaj segment generisaće izlaz Ukupan broj trouglova: 5

što znači da će biti prebrojani svi članovi tipa Trougao, dakle članovi klase Trougao, ali i tipa PravougliTrougao i RavnostraniTrougao. Pri tom, svejedno je da li se koristi metoda isInstance ili operator instanceof. Ovo, u stvari, ne treba da čudi: ono što smo želeli, to se faktički i pojavilo na izlazu, jer pravougli trougao i ravnostrani trougao jesu trouglovi, baš kao i raznostrani. Broj trouglova, kao takvih, zaista je 5. Drukčija situacija je ako se postavi pitanje "koliko članova klase Trougao ima u nizu?". Odgovor na ovo pitanje daje segment int brTroug = 0; for(Figura fig:figNiz) if(fig.getClass().equals(figure.Trougao.class)) brTroug++; System.out.println("Broj clanova klase Trougao: "+brTroug);

gde se vrednost promenljive brTroug povećava za 1 ako i samo ako element niza pripada klasi Trougao. Na kraju, napravićemo segment koji određuje broj objekata svake od klasa iz hijerarhije i to samo onih koji su trenutno prisutni u nizu figNiz. Da bi se zadatak obavio treba iterirati kroz niz, odrediti matičnu klasu svakog elementa i odgovarajući brojač povećati za 1. Da bismo ubrzali postupak iskoristićemo mogućnosti heš tabela (uočimo, potreban je brz direktan pristup brojaču). Ključ u heš tabeli tabelaFigura biće klasa kojoj pripada element, a ulogu vrednosti imaće brojač pojavljivanja klase u nizu. Postupićemo tako što ćemo pomoću iteratora for-each izvršiti se prolaz kroz niz i za svaki element izvesti sledeće: 1. metodom getClass() očitati klasa kojoj pripada element 2. ako heš tabela tabelaFigura već sadrži element sa očitanim ključem povećati odgovarajući brojač za 1 3. ako takvog elementa nema u tabeli, upisati ga sa vrednošću brojača jednakom 1 (jer je to prvo pojavljivanje odgovarajuće klase u nizu). Programski segment izgleda ovako: HashMap ,Integer> tabelaFigura = new HashMap ,Integer>(); int brojFig; //brojac figura for(Figura fig:figNiz) if(tabelaFigura.containsKey(fig.getClass())) { brojFig= tabelaFigura.get(fig.getClass()); brojFig++; tabelaFigura.put(fig.getClass(),brojFig);

8. Stringovi, omotači i kolekcije

} else tabelaFigura.put(fig.getClass(),1);

Rezultat procedure dobijamo očitavanjem heš tabele: System.out.println("\nSADRZAJ NIZA PO KLASAMA"); for(Class figClass:tabelaFigura.keySet()) { brojFig= tabelaFigura.get(figClass); System.out.println(figClass+". Broj figura: "+brojFig); }

Za stanje niza sa početka izlaganja dobijamo sledeći izlaz: SADRZAJ NIZA PO KLASAMA class figure.RavnostraniTrougao. Broj figura: 2 class figure.Pravougaonik. Broj figura: 3 class figure.PravougliTrougao. Broj figura: 2 class figure.Trougao. Broj figura: 1 class figure.Krug. Broj figura: 2 class figure.Kvadrat. Broj figura: 5

239

9. PREVENCIJA OTKAZA. OBRADA IZUZETAKA Od svakog proizvoda, pa tako i programskog sistema, očekuje se da "dobro radi", da je "kvalitetan". Kriterijumi kvaliteta softvera detaljno su razrađeni, a jedan od primarnih jeste njegova korektnost. Korektnost softvera je dobro definisan pojam: programska jedinica (program, klasa, potprogram, metoda) je korektna ako se ponaša u skladu sa specifikacijom. Neka je X skup ulaza, a Y skup izlaza shvaćenih u najširem smislu. Specifikacija S neke programske jedinice jeste relacija između skupova X i Y koja povezuje ulaze sa izlazima, tj. SXxY gde se domen specifikacije označava sa dom(S). Programska jedinica P u opštem slučaju takođe je relacija između skupova X i Y koja najčešće ima prirodu funkcije. Po definiciji domen programa obuhvata samo one ulaze za koje se program završava ili, kako se to kaže, terminira. Za programsku jedinicu P kažemo da je korektna u odnosu na specifikaciju S ako važi dom(PS) = dom(S) što znači da za svaki ulaz (a) program terminira i (b) generiše izlaz predviđen specifikacijom. Uočimo da je korektnost relativan pojam. Nijedan program nije a priori ni korektan ni nekorektan. Trivijalan program koji određuje vrednost z= a+b može biti korektan ako tako nešto piše u specifikaciji ili nekorektan ako specifikacija predviđa da treba odrediti recimo z= a-b. Korektnost realizacije klase razmatra se na dva nivoa: na nivou pojedinačnih metoda i na nivou cele klase.

9.1. KOREKTNOST METODE I KLASE Kao i svaki drugi element softverskog sistema, potprogram je korektan ako je usklađen sa specifikacijom. Ovo pak direktno otvara pitanje formulisanja specifikacije koja mora biti tačna, potpuna i razumljiva. Postoji čitav niz sredstava i modela za zadavanje specifikacija, a među popularnije spada korišćenje tzv. formula totalne i parcijalne korektnosti. Formule totalne i parcijalne korektnosti zasnovane su na matematičkoj logici, preciznije na predikatskom računu. Mogu se primeniti na delove naredbi, naredbe, potprograme (metode) i čitave programe, koje ćemo obuhvatiti jednim imenom: sintaksne jedinice. Neka je S sintaksna jedinica. Obe formule kazuju kakva je semantika S, tj. kakav se rezultat ostvaruje izvršavanjem sintaksne jedinice, a to se postiže zadavanjem tzv. preduslova i postuslova. Preduslov i postuslov (engl. "precondition" i "postcondition") su po prirodi predikati koji u različitim (apstraktnim) stanjima nekog programa imaju vrednosti  i , što

9. Prevencija otkaza. Obrada izuzetaka

241

znači da i jedan i drugi definišu određene skupove stanja. Za datu sintaksnu jedinicu S preduslov određuje stanje u kojem otpočinje izvršavanje S, a postuslov stanje u kojem se S završava. Formula totalne korektnosti je predikat koji se prikazuje sa PSQ gde su P i Q redom preduslov i postuslov. Interpretacija ove formule glasi 

Ako sintaksna jedinica S otpočinje u stanju koje zadovoljava preduslov P tada (1) S terminira (završava se) i (2) stanje po završetku S zadovoljava predikat Q.

Druga formula, formula parcijalne korektnosti, podseća na prethodnu s tim što je terminiranje deo antecedente, a ne konsekvente. Formula parcijalne korektnosti obično se prikazuje sa PSQ uz interpetaciju 

Ako sintaksna jedinica S otpočinje u stanju koje zadovoljava preduslov P i ako sigurno terminira, tada završno stanje zadovoljava predikat Q.

U čast tvorca, C.A.R. Hoare-a, izrazi gornjeg oblika zovu se i Hoarovi tripleti (trojke). Uočimo odmah da su obe formule predikati, te sledstveno mogu biti tačne, ali i netačne. Pitanje terminiranja po kojem se razlikuju dve formule je od velike važnosti u teoriji programiranja, dok se u praksi o njemu vodi nešto manje računa. Formule totalne odnosno parcijalne korektnosti omogućuju formalizaciju pojma korektnosti uopšte i posebno korektnosti potprograma (statičke metode u javi): 



Potprogram S je totalno korektan u odnosu na specifikaciju formulisanu uređenim parom (P,Q) preduslova i postuslova ako je predikat PSQ tačan. Ista tvrdnja važi i za metodu. Potprogram je parcijalno korektan ako zadovoljava isti uslov, ali uz korišćenje formule parcijalne korektnosti PSQ.

Pošto je formula totalne korektnosti nešto više tretirana u literaturi, u nastavku ćemo se zadržati samo na njoj. Kako smo rekli, primenljiva je na sve nivoe složenosti, od dela naredbe, pa do čitavog programa. Na primer, formula x=1 x:=x+1 x'=2 znači da sintaksna jedinica dodele prevodi proces iz svakog stanja u kojem je vrednost promenljive x bila 1 u stanje u kojem x ima vrednost 2. Oznake x i x' su uobičajene za vrednost promenljive x pre odnosno posle izvršavanja sintaksne jedinice. Za istu sintaksnu jedinicu može se definisati proizvoljan broj Hoarovih tripleta, tačnih i netačnih. Sledeći tripleti su tačni: x=1 x:=x+1 x'>1 x=1 x:=x+1 x'0 x=2 x:=x+1 x'=3 a sledeći nisu: x=1 x:=x+1 x'=1

9. Prevencija otkaza. Obrada izuzetaka

242

x=1 x:=x+1 x'<0 x=2 x:=x+1 x'=2 Pitanjima jednoznačnog definisanja preduslova odn. postuslova bavili su se Dajkstra i Flojd. Ono što je od interesa za naša razmatranja jeste korišćenje Hoarovih tripleta u svrhu definisanja semantike potprograma i naročito metoda. Neka je f potprogram ili metoda neke klase. Neka su P i Q predikati koji predstavljaju redom preduslov i postuslov. Ako uređeni par (P,Q) prihvatimo kao formalizaciju specifikacije tada je f korektna u odnosu na specifikaciju (P,Q) ako je predikat PfQ tačan. Neka je sort funkcija koja služi za sortiranje realnog niza s sa n2 elemenata u rastućem poretku. Tada se korektnost sort istražuje na Hoarovom tripletu (s je realan niz dužine n)(n  2) sort(s,n) s'i  s'i+1, i=1, ..., n-1 Ako je triplet tačan kažemo da je sort korektan u odnosu na specifikaciju datu preduslovom i postuslovom. Kao što vidimo, preduslov i postuslov mogu da se zadaju strogo, korišćenjem matematičke notacije, ali i manje formalno, upotrebom govornog jezika. Sve što je potrebno jeste ispunjenje zahteva u pogledu tačnosti, potpunosti i razumljivosti. Inače, Hoarovi tripleti imaju primenu i izvan razmatranja korektnosti. Jedan od vrlo često korišćenih načina komentarisanja potprograma obuhvata uključivanje preduslova i postuslova. Komentar se zadaje na samom početku potprograma (preciznije, iznad zaglavlja) i u najužoj formi obuhvata opis posla koji potprogram obavlja, zatim preduslov i konačno postuslov. U dosadašnjem izlaganju koncentrisali smo se na opšta pitanja korektnosti koja su vezana za sve sintaksne jedinice tipa potprograma. Razmatranje korektnosti metoda umnogome se poklapa sa razmatranjem korektnosti (slobodnih) potprograma, jer i same metode imaju mnoge osobine potprograma. Razlika naravno postoji i proističe iz nesamostalnosti metoda, što ne može a da nema uticaja i na definisanje odgovarajućih Hoarovih tripleta. Naime, preduslov odn. postuslov metode na neki način moraju zavisiti i od stanja objekta kojem se putem aktiviranja šalje poruka, čime se korektnost metoda direktno povezuje sa korektnošću klase. S druge strane, klasa nije prost skup metoda te se ni njena korektnost ne može svesti samo na nekakav "zbir" korektnosti pojedinačnih metoda. Uopšte uzev, formalna korektnost svake metode ponaosob ne garantuje korektnost ponašanja klase u celini. Posmatrajmo, kao primer, klasu Trougao i njenu metodu povrsina(). S obzirom na to da metoda nema parametara moglo bi se zaključiti da je njen preduslov PT, tj. da u svakom stanju objekta klase Trougao metoda izdaje tačan rezultat. Ovo je naravno pogrešno jer PT obuhvata i stanja u kojima su stranice trougla, recimo, negativne! Razrešenje ovog problema ne treba tražiti direktno u definisanju oblika preduslova nego na drugoj strani: u propisivanju dozvoljenih stanja objekta klase. Drugim rečima, treba poći od pitanja "može li se dozvoliti da objekat klase Trougao bude u stanju u kojem su dužine stranica negativne?". Iako je odgovor svakako "ne može", pitanje nije baš sasvim retoričko jer treba razjasniti i zašto ne može. Nijedan objekat klase Trougao ne sme biti u pomenutom stanju jer takav entitet ne postoji, a objekat je - ne zaboravimo - model entiteta. Entiteti koje u domenu problema uključujemo u zajedničku klasu entiteta imaju iste bitne osobine - one na osnovu kojih su uvrštene u klasu. Svi entiteti klase entiteta TROUGAO imaju po tri stranice. To, međutim, nije sve jer između osobina entiteta postoje neke relacije koje se moraju očuvati u svakom od entiteta klase. U klasi entiteta TROUGAO to je dobro poznata karakteristika da zbir dužina ma koje dve stranice mora biti veći od dužine treće. Kada se to prenese na nivo modela sledi da svi objekti date klase imaju iste članove, ali i da održavaju neke konstantne relacije između njih. Ako su s1, s2 i s3 podaci-članovi klase Trougao koji predstavljaju dužine stranica, tada za svaki objekat u svakom njegovom stanju mora važiti

9. Prevencija otkaza. Obrada izuzetaka

243

(s1<s2+s3)(s2<s1+s3)(s3<s1+s2). Obratimo pažnju na to da je ovo ograničenje suštinsko, jer objekat klase Trougao ne može uopšte postojati ako ne ispunjava navedeni uslov! Ograničenja se mogu pojaviti i kao rezultat načina realizacije klase. Primerice, sekvencijalno realizovan stek sa n elemenata čiji je kapacitet c stalno ispunjava uslov nc. Slična ograničenja postoje za svaku klasu objekata jer su deo definicije odgovarajuće klase entiteta ili pak deo realizacije i nose naziv invarijante klase. Neformalno, invarijanta klase jeste dakle skup tvrdnji koje važe za svaki objekat u svakom stanju. Zapazimo odmah da invarijanta važi u svakom stanju ali ne i u svakom trenutku, pošto u prelaznom režimu može da se naruši. Naravno, po izvršenom prelazu invarijanta se obavezno ponovo uspostavlja, ako je uopšte bila narušavana. Takođe, ne postoji eksplicitni zahtev da invarijanta bude jedinstvena. Opskrbljeni konceptom invarijante klase možemo se vratiti na razmatranje korektnosti metoda. Kako smo videli, invarijanta klase mora biti zadovoljena u svakom stanju objekta. S druge strane, promene stanja izvode se isključivo posredstvom metoda, što neposredno vodi ka novim zaključcima o preduslovima i postuslovima metoda. Ako za trenutak ostavimo po strani metode koje kreiraju odnosno uništavaju objekte, sve ostale metode iz interfejsa klase moraju održavati njenu invarijantu. To znači da one otpočinju i isto tako završavaju u stanjima koja zadovoljavaju invarijantu klase. Izraženo jezikom Hoarovih tripleta to znači da je invarijanta klase nezaobilazni deo kako preduslova tako i postuslova svake metode osim metoda za kreiranje i uništavanje. Neka je m metoda klase K sa punim preduslovom PRm odnosno postuslovom POm. Ako je IK invarijanta klase tada preduslov i postuslov nužno imaju oblik PRm = PmIK POm = QmIK gde su Pm i Qm preduslov i postuslov kojima rukujemo, dok se invarijanta klase IK podrazumeva kao obavezni deo. Kada, dakle, za metodu m formiramo Hoarov triplet PmmQm, u stvari podrazumevamo PmIK m QmIK. Sada možemo pristupiti definiciji korektnosti klase u celini. Klasa K sa invarijantom IK je korektna ako zadovoljava sledeće uslove: 1. Za svaki konstruktor c (ili inicijalizator ako programski jezik nema takvu vrstu konstruktora) važi Pc c(argumenti) QcIK, što znači da konstruktor uspostavlja invarijantu. 2. Za svaku otvorenu (public) metodu m važi PmIK m(argumenti) QmIK.

9.2. PREVENCIJA OTKAZA. RUKOVANJE IZUZECIMA Svaki, pa i sasvim jednostavan sistem sadrži defekte. Softver, kao potencijalno visoko kompleksan sistem, toliko je podložan greškama da je sasvim opravdano pretpostaviti da ih svaki programski sistem ima. Praksa samo potvrđuje ovaj stav: analizom velikog broja projekata ustanovljeno je da složeni softverski sistemi sadrže 1-2% naredbi sa greškama (Lipajev, Li83) što je, imajući u vidu njihovu veličinu, itekako respektabilan iznos. Kada su u pitanju greške, kvalitetan program mora da ispuni dva zahteva. Prvo, treba da bude korektan, tj. da odgovara specifikaciji, o čemu smo govorili u prethodnom odeljku. Drugo, mora biti robustan što znači otporan na neregularne ulazne podatke. Ova dva zahteva nisu međusobno uslovljena. Korektan program, dakle napisan u skladu sa specifikacijom, nije obavezno zaštićen od unosa neregularnih (tzv. invalidnih) ulaznih podataka. Može čak da reaguje nepredvidivo ili, kako se u engleskom žargonu kaže, da izvede "jump in blue". S druge strane, u robustnom programu nema takvih poslastica, ali ni garancije da će izlaz biti

9. Prevencija otkaza. Obrada izuzetaka

244

tačan. Mejer [Me03 pojmove korektnosti i robustnosti objedinjava u pouzdanost, mada neki autori pouzdanost poistovećuju samo sa robustnošću. U programerskom žargonu uobičajeno je da se svaka anomalija naziva greškom, često i "bagom" (od engleskog bug = buba, zbog insekta koji je svojevremeno izazvao kratak spoj u računaru). Stručnjaci za ovu oblast računarstva pak upotrebljavaju znatno širu taksonomiju Jo95 koju ćemo ukratko izložiti. Prvo, u toku procesa realizacije, programer može da pogreši u donošenju odluke o upisu nekog koda u program. Ova vrsta mentalne aktivnosti nosi naziv greška (engl. "error") u užem smislu reči. Rezultat greške pojavljuje se u programu kao defekt ("fault"). Ako se u toku izvršavanja programa naiđe na defekt, dolazi do otkaza ("failure"). Otkaz može da se manifestuje, ali ne mora. Eksplicitna, vidljiva manifestacija otkaza nosi naziv incident. Inače, otkaz može da se manifestuje na više načina:  

 

Ne izaziva incident, što je krajnje nepoželjno jer pogrešan rezultat generisan programom prolazi neopaženo. Uzrokuje nepredviđeni prekid programa što takođe nije naročito privlačno, ali je bolje od prethodnog jer korisnik ipak dobija informaciju o tome da sa programom nešto nije u redu. Izaziva predviđeni ("havarijski") prekid programa. Ovo je nešto malo povoljnije od prethodnog, jer korisnik dobija informaciju o prekidu programa i uzroku prekida. Program se privremeno zaustavlja, generiše se poruka o otkazu i korisniku nudi repertoar aktivnosti iz kojeg se bira način reakcije.

Inače, otkaz programa može izazvati i zaustavljanje ("pad") operativnog sistema, što nije nimalo prijatno. Međutim, u takvim situacijama ostaje otvoreno pitanje da li je otkaz operativnog sistema rezultat defekta u programu ili - što je verovatnije - propusta u samom operativnom sistemu. U objektnom ambijentu, postoje dva tipična slučaja pojave defekta: jedan je defekt u metodi neke klase; drugi se pak odnosi na defekt u klijentu, gde se korektna metoda poziva u neregularnim uslovima (npr. pokušaj čitanja iz prazne liste). Iako se u oba slučaja radi o pogrešno unetom kodu, postoji razlika u tretmanu. Defektna naredba u samoj metodi (ako nije poziv druge metode) sa velikom verovatnoćom poklapa se sa mestom otkaza ili mu je bar blizu. Najčešće se traži pokušajem izazivanja incidenta u uslovima neizvesnosti, jer se ne zna da li defekt uopšte postoji i posebno gde je lociran. Defekt u klijentu se ne nalazi na mestu otkaza. Primer je upravo pokušaj očitavanja prazne liste gde je (defektna) naredba očitavanja u klijentu, dok je mesto manifestovanja otkaza u (korektnoj) metodi klase-servera. Otkrivanje defekta u klijentu može se olakšati ako je pozvana metoda snabdevena zaštitom koja će sprečiti otkaz usled pogrešnog poziva i o tome izvestiti. Postoje tri načina za predupređivanje otkaza, od kojih su prva dva karakteristična za sve procedurne jezike. Radi se o sledećim postupcima: 1. Upravljanje putem prekida programa, gde u slučaju otkaza potprogram77 u kojem je nastao otkaz nameće potpuni prekid izvršavanja programa preko standardnih rutina (npr. abort u C/C++, Halt u paskalu ili System.exit u javi). 2. Upravljanje preko izlaza potprograma - metode, gde se prosleđivanje koda ishoda klijentu vrši putem izlazne vrednosti. 3. Primena posebnog mehanizma, tzv. rukovanja izuzecima, pod uslovom da ga programski jezik poseduje. Stariji programski jezici (paskal, C) nemaju ugrađeno rukovanje izuzecima. Zajednička karakteristika sve tri metode jeste preventivnost, tj. sprečavanje izvršavanja naredbi koje izazivaju otkaz. Prve dve metode primenljive su u praktično svim imperativnim programskim jezicima, dok je treća novijeg datuma. 77

Pošto materija koja se izlaže u ovom odeljku važi i za imperativne i za objektne jezike, do prelaska na javin mehanizam upšotrebljavaćemo termin "potprogram" imajući na umu da sve izloženo važi i za metode.

9. Prevencija otkaza. Obrada izuzetaka

245

Prvi tip upravljanja otkazima upotrebljava se u slučajevima havarije programa, kada je jedina suvisla reakcija njegovo momentalno prekidanje. Karakterističan je po tome što se reakcija na otkaz nalazi takođe u potprogramu, a ne u klijentu. Takođe, diskutabilno je u kojoj meri ovaj postupak stvarno služi za prevenciju otkaza jer se očigledno svodi na sprečavanje jednog otkaza izazivanjem drugog. Drugi način za obradu otkaza - prosleđivanje klijentu koda (šifre) otkaza - ne zahteva od programskog jezika nikakve specijalne odlike, te je zato na raspolaganju u svakom imperativnom jeziku uključujući i najstariji - fortran. Izvodi se tako što povratna vrednost rizičnog potprograma više nije traženi rezultat, nego predstavlja kod (šifru) ishoda koja se vraća klijentu na obradu, dok se osnovni izlaz prosleđuje putem izlaznog argumenta. Rukovanje izuzecima (engl. "exception handling") je najbolji način za obradu iole složenijih otkaza. Neformalno, izuzetak je događaj koji se dešava kao posledica izvršavanja defektnog koda. Pošto isto važi i za otkaz, može se steći pogrešan utisak da se radi o sinonimima. Radi se, međutim, o sasvim različitim vrstama događaja i to iz tri razloga: (1) svrha izuzetka jeste upravo sprečavanje pojave otkaza; (2) otkaz je neželjeni događaj, dok se izuzetak izaziva hotimice, ugrađivanjem posebnih naredbi i (3) izuzetak se uvek manifestuje. Izuzetak se ne može poistovetiti ni sa incidentom jer ni do incidenta ne dolazi namerno, tako da o izuzetku možemo govoriti kao o pseudo-incidentu (lažnom incidentu). Moguća definicija izuzetka bila bi: 

Izuzetak (engl. "exception") je namerno izazvan događaj čija je svrha predupređivanje otkaza i koji ostavlja program u zatečenom stanju (status quo ante). Obavezno je propraćen prijavom nastanka.

Mejer Me03 daje možda najčistiju sliku odnosa otkaza i izuzetka. On polazi od ishoda izvršavanja rutine koji može da bude uspešan ako rutina završi u stanju predviđenom specifikacijskim postuslovom, odnosno neuspešan u suprotnom. I otkaz i izuzetak izazivaju neuspešan ishod rutine, ali je razlika u tome što je izuzetak kontrolisan i što sam po sebi ne menja zatečeno stanje programa. Postupak rukovanja izuzecima podrazumeva način programiranja koji će obezbediti detekciju barem očekivanih izuzetaka; drugim rečima, izaziva se incident78 i klijent se izveštava o njegovom nastanku i uzroku. Osnovna ideja preuzeta je iz metode 2 za predupređivanje otkaza, s tim da kod izuzetka ne pripada ni listi argumenata niti je izlaz potprograma. Prenosi se i prihvata kao poseban, nevidljiv podatak ili objekat, čime se otklanja osnovni nedostatak metode 2 - upotreba izlaza potprograma u svrhu za koju nije predviđen. Ukoliko je potrebno, izuzetak može da izazove i prekid programa, tako da rukovanje izuzecima obuhvata obe prethodne metode. Metoda je zasnovana na sledećim principima:  

Izuzetak generisan nekom porukom detektuje se na mestu nastanka, a obrađuje na mestu odakle je poruka poslata. Izuzetak je (kontrolisana) anomalija te, shodno tome, zahteva poseban tretman.

Kako vidimo, upravljanje otkazima prekidom programa ne poštuje prvi princip, jer se prekid nalazi u potprogramu u kojem je nastao incident, dok upravljanje putem izlaza potprograma nije u skladu sa drugim principom, jer poruku o incidentu prosleđuje istim kanalima kojima prosleđuje i regularne rezultate.

9.3. PREVENCIJA OTKAZA U JAVI Java poseduje sve tri vrste prevencije otkaza pomenute u prethodnom odeljku. Prvi, bezuslovno prekidanje kompletnog programa, vrši se pomoću metode static void exit(int status)

78

Tačnije, izaziva se pseudo-incident jer do otkaza ne dolazi.

9. Prevencija otkaza. Obrada izuzetaka

246

Metoda se nalazi u klasi System. Poziva se, dakle, sa System.exit(n)

gde je n kod izlaza koji je konvencionalno jednak 0 ako je program terminirao normalno (što nije od interesa) ili je veći od nule što označava da je u pitanju havarija. Sama metoda exit zaustavlja virtuelnu mašinu JVM. Podvucimo još jednom, ovaj način je najprimitivniji od svih i treba ga koristiti tada i samo tada kada JVM treba da pretrpi promenu stanja koja se apsolutno ne sme dogoditi, tj. kada je imperativ momentalno zaustavljanje virtuelne mašine. Kostur metode koja sadrži potencijalni havarijski prekid je modifikatori tip metoda { . . . . . if(havarija) System.exit(1); . . . . . }

Za razliku od prvog, retko korišćenog, postupka za rukovanje otkazima, upravljanje preko izlaza metode spada u standardne postupke i primenjuje se naporedo sa rukovanjem preko izuzetaka. Koristili smo ga u više navrata i u ovoj knjizi, recimo u primeru 6.2 (paket players sa plejerima) gde mnogo void metoda koje, po svojoj prirodi, ne vraćaju rezultat dobija tip boolean i vraća vrednost true ili false, u zavisnosti od uspeha izvršenja. Takođe, mnoge standardne javine klase imaju takve metode, poput metoda put u kontejnerskim klasama koje opet vraćaju true ili false zavisno od uspeha. Neka je m neka metoda koja ne vraća rezultat, ali koja može da se izvrši samo kada je ispunjen uslov cond. Rukovanje otkazima preko izlaza podrazumeva da metoda m ipak generiše izlaz logičkog tipa koji je jednak true ako je uspešno izvedena (tj. ako je preduslov cond bio ispunjen), odnosno false u suprotnom. Kostur metode izgleda ovako: boolean m(parametri) { if(!cond) return false; //izvrsni kod metode i vracanje rezultata true }

Po potrebi, metoda može da vrati i rezultat koji nije true-false nego je npr. int gde vraćena vrednost sadrži ne samo podatak uspešno-neuspešno, nego i vrednost koja kodira razlog neuspeha, ako takvih razloga može biti više. Kada se želi bezbedan poziv metode m, naredba ima sledeći oblik if(!m(argumenti)) postupak za slucaj greske;

Metode tipa void najpogodnije su za primenu ovog postupka. Kada se radi o metodama što vraćaju vrednost, situacija je nešto drukčija. Izlaz je već rezervisan za rezultat i ne smatra se dobrim stilom programiranja promeniti mu osnovnu namenu tako što bi se rezultat vratio preko liste parametara. Ono što je moguće učiniti jeste iskoristiti posebnu vrednost rezultata koja nije obuhvaćena specifikacijom (ako takva uopšte postoji) i upotrebiti je kao indikaciju greške. U praksi, radi se o metodama koje vraćaju za rezultat objekat (a ne bazni tip), gde se kao indikacija greške koristi vrednost null. Dakle, ako imamo metodu n koja vraća objekat klase K pod uslovom cond, njen kostur ima tipičan oblik modifikatori K n(parametri) { if(!cond) return null; . . . . . }

9. Prevencija otkaza. Obrada izuzetaka

247

Zaštićen poziv ovakve metode podrazumeva proveru da li je vraćeni rezultata null. Ako je u pitanju poziv metode u okviru dodele (čest primer) recimo objektu ob, naredba ima opšti oblik if((ob=n(argumenti))==null) postupak u slucaju greske;

Najveći problem predstavljaju metode koje vraćaju bazne tipove: prvo, nije uvek moguće usvojiti neku vrednost koju metoda ne može da vrati pod normalnim okolnostima. Drugo i daleko gore: metode što vraćaju bazne tipove pozivaju se često u sklopu izračunavanja izraza, tako da zaštićeni poziv posebnom naredbom nije moguć. Nedozvoljena vrednost koja metodi služi za slanje indikacije neuspešnosti tada bi ušla u proračun vrednosti izraza u kojem je pozvana. Neka je y(a) metoda koja vraća int vrednost veću od 0, pri čemu parametar a mora biti veći od 0. Metoda upravljanja otkazima preko izlaza nalagala bi da, u slučaju da a ima nedozvoljenu vrednost, metoda vrati rezultat koji nije predviđen specifikacijom, recimo 0. Međutim, u tom slučaju naredba poput t= 3+2*y(j);

bila bi izvršena i tada kada je j0, u kojem slučaju t dobija (pogrešnu) vrednost 3! Pošto je ovako nešto u programiranju striktno zabranjeno, jasno je da upravljanje otkazima preko izlaza, za metode koje vraćaju bazne tipove nije dobro rešenje. Da bismo ilustrovali upravljanje otkazima preko izlaza metode, razmotrićemo sekvencijalno realizovan stek. Neka su polja steka int t,c; Object s[];

gde je t indeks vrha steka, c njegov kapacitet, a s niz u koji se upisuju elementi. Stek se kreira konstruktorom oblika Stack(int capacity) { s= new Object[capacity]; c= capacity; t= -1; }

gde vrednost t=-1 znači da je u početnom stanju stek prazan. Metode top() za očitavanje vrha steka, pop() za uklanjanje elementa sa vrha i push(Object el) za upis u sirovom obliku (bez zaštite) izgledaju ovako: object top() { return s[t]; } void pop() { t--; } void push(Object el) { s[++t]= el; }

Prve dve metode izvršavaju se pod uslovom da stek nije prazan, tj. da važi t>-1. Metoda push zahteva da stek ne bude popunjen, tj. da ne bude t=c-1. Pored toga, metoda top vraća vrednost tipa Object dok su druge dve tipa void. Shodno tome, ako hoćemo da iskoristimo izlaz za prevenciju otkaza, metoda top generisaće rezultat null u slučaju pokušaja očitavanja praznog

9. Prevencija otkaza. Obrada izuzetaka

248

steka; metoda pop dobiće tip boolean i vratiće vrednost false pri pokušaju uklanjanja iz praznog steka; metoda push postaće takođe boolean i generisaće rezultat false u situaciji upisa u već pun stek. Modifikovane metode sada dobijaju sledeći oblik: Object top() { return (t>-1) ? s[t] : null; } boolean pop() { if(t<0) return false; t--; return true; } boolean push(Object el) { if(t==c-1) return false; s[++t]= el; return true; }

Uočimo, na kraju, da realizacija kontejnerskih metoda get, remove i put koristi upravo ovakav pristup za rukovanje otkazima. 9.3.1. Rukovanje izuzecima u javi Iz dosadašnjih izlaganja lako je zapaziti da je upravljanje otkazima preko izlaza u suštini zasnovano na "priručnom sredstvu", tj. na sredstvu kojem to nije osnovna namena. Pored toga (i usled toga) ova metoda, videli smo, ne funkcioniše uvek i ne funkcioniše na isti način: neki put koristi se logički izlaz, a neki put null ili druga specijalna vrednost. S druge strane, korišćenje izlaza za prevenciju otkaza je jednostavno i primenljivo u doslovno svakom imperativnom jeziku uključujući i stare verzije fortrana ili bejsika. Mehanizam rukovanja izuzecima jeste univerzalno sredstvo koje je zamišljeno tako da funkcioniše u svim situacijama. Osnovna ideja vezana je za način razmene podataka između klijenta i pozvane metode. Naime, u standardnim procedurnim jezicima razmena podataka između klijenta i potprograma obavlja se u logičkom smislu jednim jedinim kanalom koji obuhvata ulazno-izlazne parametre i rezultat, kako je prikazano na slici 9.1. ulazno-izlazni parametri

klijent

potprogram

rezultat

Slika 9.1. Sistem rukovanja izuzecima, kao sredstvo za prevenciju otkaza, podrazumeva uvođenje još jednog kanala komunikacije između klijenta i (u ovom slučaju) metode oslobađajući tako kanale za razmenu podataka, slika 9.2. Da bi se to postiglo neophodno je u programski sistem uvesti novi podsistem - podsistem za rukovanje izuzecima, što dakle uslovljava izmene u programskom jeziku. Podsistem za rukovanje izuzecima postoji u javi, C++ i Object Pascal-u (Delphi). Standardni procedurni jezici poput paskala, C-a ili fortrana nemaju ovu mogućnost.

9. Prevencija otkaza. Obrada izuzetaka

249

ulazno-izlazni parametri

metoda

klijent

izuzeci

rezultat

Slika 9.2. Predaja odnosno prijem podataka ovim, novim kanalom vrše se posebnim naredbama o kojima će uskoro biti reči. Izuzeci u javi su, shodno osnovnom principu, realizovani kao objekti iz mnoštva različitih klasa uređenih u posebnu hijerarhiju u okviru paketa java.lang. Koren hijerarhije klasa izuzetaka jeste klasa sa nazivom Throwable. Njeni neposredni potomci su klase Exception i Error, pri čemu je ova druga rezervisana za sistem i ne treba je koristiti. Shodno tome, klasa Exception predstavlja koren subhijerarhije u koju spadaju klase što su na raspolaganju programeru za neposredno korišćenje ili za izvođenje sopstvenih klasa izuzetaka. Među neposrednim potomcima klase Exception nalazi se i klasa RuntimeException koja, kako ćemo videti, ima neke specijalne osobine. Object Throwable

Error

Slika 9.3.

Exception

RuntimeException

....

Klase izuzetaka raspolažu sa desetak metoda od kojih izdvajamo dva konstruktora i tri metode koje poseduju sve klase. To su konstruktori Konstruktor() Konstruktor(String poruka) String getMessage() void printStackTrace() String toString()

Prva metoda je običan konstruktor (sa imenom klase izuzetaka kojoj pripada). Drugi konstruktor prima kao argument poruku što će se preneti klijentu u slučaju generisanja izuzetka. Metoda getMessage se koristi na strani klijenta za preuzimanje te poruke. Metoda printStackTrace prikazuje na ekranu sekvencu poziva metoda do trenutka generisanja izuzetka, tako da programer može da rekonstruiše tok događaja do nastanka izuzetka. Konačno, metoda toString() je ista ona koja se pojavljuje i u drugim klasama. Za rukovanje izuzecima mogu se koristiti gotove klase ili, nasleđivanjem, realizovati sopstvene klase izuzetaka. U praksi se radi i jedno i drugo. Evo jednog primera programerski definisane klase izuzetaka: public class NegativeArgException extends Exception { public NegativeArgException () { super("NEGATIVE ARGUMENT"); }

9. Prevencija otkaza. Obrada izuzetaka

250

}

Klasa nasleđuje klasu Exception i ima samo konstruktor koji generiše poruku NEGATIVE ARGUMENT. Ova poruka prenosi se baznoj klasi, tako da se pri svakom generisanju izuzetka iz klase NegativeArgException pojavljuje ista poruka: NEGATIVE ARGUMENT. Ostale metode su nasleđene bez redefinisanja. Inače, da smo želeli da poruka koja se šalje bude promenljiva a ne uvek ista, upotrebili bismo drugu vrstu konstruktora (onaj sa argumentom poruka). Generisanje izuzetka vrši se posebnom naredbom sa opštim oblikom throw new konstruktor(argument) gde je konstruktor konstruktor klase izuzetaka iz koje želimo da kreiramo izuzetak, dok argument predstavlja ili string sa porukom ili ga nema (a tada se šalje standardna poruka). Na primer if(x<0) throw new NegativeArgException();

Metoda koja generiše izuzetak ili izuzetke mora ih i deklarisati. Neka je m metoda u kojoj se generišu izuzeci iz klasa Ex1, ..., Exn. Tada kostur metode izgleda ovako: modifikatori tip m(parametri) throws Ex1,...,Exn { //naredbe }

Pri tom, važe sledeća pravila: 1. Ako je Exi klasa izuzetaka koja je deklarisana u metodi m, tada metoda može generisati izuzetke iz te klase ili iz njenih potomaka. Drugim rečima, i ovde važi inkluzioni polimorfizam. To takođe znači da metoda u kojoj je deklarisana klasa Throwable može generisati doslovce sve vrste izuzetaka (čak i klase Error), a ako je deklarisana klasa Exception, sve programerski relevantne izuzetke. Prema tome, klase Throwable i (naročito) Exception mogu da posluže kao univerzalne klase izuzetaka. 2. Klasa izuetaka RuntimeException ne mora se deklarisati. Dakle, ako neka metoda generiše izuzetak iz ove klase ili nekog njenog potomka deklaracija throws nije neophodna. Posmatrajmo jednostavnu statičku metodu f koja služi za računanje izraza 2*sin(x)*sqrt(x). Metodu ćemo snabdeti zaštitom za slučaj da je parametar x manji od 079. Jedna verzija metode f (u oznaci f1) je sledeća: public static double f1(double x) throws NegativeArgException { if(x<0) throw new NegativeArgException(); return 2*Math.sin(x)*Math.sqrt(x); }

Pošto klasa NegativeArgException nasleđuje klase Exception odn. Throwable, mogla je biti deklarisana i ovako: public static double f1(double x) throws Exception { if(x<0) throw new NegativeArgException(); return 2*Math.sin(x)*Math.sqrt(x); }

79

Funkcija sqrt je, naravno, već zaštićena. Ovde uvodimo zaštitu samo kao ilustraciju.

9. Prevencija otkaza. Obrada izuzetaka

251

Umesto Exception mogla je da se stavi i klasa Throwable. Pošto programer ne treba da se bavi izuzecima klase Error, klasa Exception češće se koristi kao univerzalna klasa izuzetaka nego Throwable. Ako iz bilo kojih razloga ne želimo da deklarišemo klasu izuzetaka upotrebićemo klasu RuntimeException, pošto svaka metoda može da generiše takav izuzetak bez posebnog deklarisanja. Potpunosti radi, napominjemo da ovde imamo dva rešenja: jedno je da klasu izuzetaka NegativeArgException umesto iz Exception izvedemo iz RuntimeException. Pod pretpostavkom da je to urađeno, tekst metode f1 isti je kao i gore, ali bez obavezne deklaracije throws. Drugo rešenje je da klasu RuntimeException upotrebimo direktno: nema throws! public static double f2(double x) { if(x<0) throw new RuntimeException("NEGATIVE ARGUMENT"); return 2*Math.sin(x)*Math.sqrt(x); }

Uočimo da je u ovom slučaju upotrebljen konstruktor klase RuntimeException sa odgovarajućom porukom. Generisanje izuzetka naredbom throw uzrokuje prekid izvršavanja metode i predavanje upravljanja klijentu. No, tu se stvar ne završava: klijent reaguje na to tako što obradi izuzetak ili ga pak prenosi svom klijentu itd. Ako ni jedna od metoda u lancu prekida, zbog izuzetka, ne obradi prekid, on će biti prenet u metodu main pa i dalje u JVM. Neka je m metoda koja generiše izuzetak. Neka je lanac poziva bio k0(main),k1, k2,...,kn, u smislu da je metoda k0 pozvala metodu k1, metoda k1 metodu k2 ... metoda kn metodu m, slika 9.4. Kada metoda m generiše izuzetak, on se prenosi u suprotnom smeru od lanca poziva, dakle u metodu kn. Metoda kn može obraditi izuzetak i time završiti, ili ga predati metodi kn-1 koja ima istu mogućnost: da izuzetak obradi ili ga preda metodi kn-2 itd. main k1

izuzetak

. . .. kn poziv

m

Slika 9.4. Svaka od metoda u lancu poziva metode m (koja, ne zaboravimo, generiše izuzetak) može da reaguje, tj. da obavi prihvat izuzetka, na tri načina: 1. Metoda može da prosledi izuzetak svom klijentu bez ikakve obrade. 2. Metoda može da u potpunosti obradi izuzetak bez prosleđivanja klijentu višeg nivoa. 3. Metoda može da obradi izuzetak i da ga prosledi klijentu višeg nivoa. Primetimo da je sistem za rukovanje izuzecima koncipiran tako da klijent mora da reaguje na izuzetak, tako da on ne može proći "nezapaženo"! Prosleđivanje izuzetka klijentu višeg nivoa je jednostavno: treba ga samo deklarisati pomoću konstrukta throws. Neka je metoda m sa slike generisala izuzetak iz klase MyException. Neka je taj izuzetak, na ma koji način, "stigao" do metode ki. Ako metoda ki treba samo da prosledi izuzetak metodi ki-1 njen kostur treba da ima sledeći oblik: modifikatori tip ki(parametri) throws MyException { . . . . . . . . . . }

9. Prevencija otkaza. Obrada izuzetaka

252

Naravno, umesto MyException može se upotrebiti i Exception ili Throwable (ne zaboravimo: klasa izuzetaka mora naslediti klasu Exception direktno ili indirektno - sve drugo je greška programera!). I ovde je klasa RuntimeException posebna: ako MyException nasleđuje RuntimeException (ili ako je izuzetak baš iz klase RuntimeException), prenos izuzetka vrši se bez ikakvog dodatnog koda. Neka je potrebno napraviti metodu printf za prikaz na ekranu vrednosti funkcije f1 pomenute ranije u ovom odeljku. Metoda f1 generiše izuzetak iz klase NegativeArgException. Ako je potrebno prosto preneti izuzetak na viši nivo poziva, takva metoda imala bi sledeći oblik: public void printf(double y) throws NegativeArgException { System.out.println("f("+y+")="+f1(y)); }

Ukoliko je argument y manji od nule, metoda printf neće biti završena - doćiće do prekida usled toga što je metoda f1 generisala izuzetak. S druge strane, sama metoda printf ne reaguje direktno na izuzetak nego ga prosleđuje metodi iz koje je pozvana. Da je za prikaz, umesto varijante f1, korišćena varijanta f2, konstrukt throws ne bi bio neophodan. Prosleđivanje izuzetaka klijentima nije jedini način za njihovu obradu. Štaviše, kada ne bi bilo drugih mehanizama, rukovanje izuzecima ne bi ni imalo smisla: izuzetak generisan u metodi m sa slike 9.4 bio bi prosleđen sve do metode main i preko nje virtuelnoj mašini koja bi se zaustavila. Ukupni efekat bio bi isti kao da je metoda m izazvala havarijski prekid putem System.exit()! Očigledno, mora postojati neki način da se propagacija izuzetka kroz metode što čine lanac poziva - zaustavi. Sredstvo za ovakav tretman izuzetka postoji svuda gde postoje izuzeci i gotovo da se ne razlikuje od jezika do jezika (Object Pascal, C++, java). Radi se o posebnoj naredbi nazvanoj try, čija je svrha da zaustavi propagaciju izuzetka i, uopšte, da omogući rukovanje izuzecima u pravom smislu reči. Naredba ima opšti oblik: try { //blok sa naredbama koje generisu izuzetke ("blok try") } catch(ExClass1 e) { rukovalac izuzetkom //obrada izuzetka e iz klase ExClass1 } catch(ExClass2 e) { //obrada izuzetka e iz klase ExClass2 . . . . . } catch(ExClassN e) { //obrada izuzetka e iz klase ExClassN } finally { //blok sa naredbama koje se sigurno izvrsavaju može se izostaviti }

Neposredno iza naredbe try sledi tzv. "try blok" u kojem se nalazi segment sa naredbama među kojima su i one koje mogu generisati izuzetak. Blok se izvršava sekvencijalno, kao i svaki drugi blok, s tim da ako dođe do pojave izuzetka, obrada bloka se momentalno prekida. Naredbe koje u bloku slede naredbu što je izazvala pojavu izuzetka preskaču se i prelazi se na obradu izuzetka. Obrada izuzetaka vrši se pomoću posebnih rutina koje nose naziv rukovaoci izuzetkom (engl. "exception handler"). Radi se o rutinama koje imaju gotovo sve osobine slobodnih potprograma, osim što su nesamostalne, jer predstavljaju deo naredbe try i što imaju isto ime - catch. Opšti oblik jednog rukovaoca izuzetkom je catch(Klasa_izuzetaka objekat_izuzetak) { //naredbe, ukljucujuci i //metode klase Klasa_izuzetaka primenjene na objekat_izuzetak }

Rukovalac izuzetkom ima jedan parametar: objekat iz klase izuzetaka koji se obrađuje u rukovaocu. U blok rukovaoca mogu se uneti bilo kakve naredbe, uključujući i metode klase

9. Prevencija otkaza. Obrada izuzetaka

253

izuzetaka primenjene na objekat-argument rukovaoca, recimo getMessage() ili printStackTrace(). U okviru naredbe try može se navesti proizvoljan broj rukovalaca. Kada se generiše izuzetak, blok try se prekida i iz sekvence rukovalaca bira se prvi po redu koji može da prihvati prijavljeni izuzetak. Prema tome, redosled navođenja rukovalaca nije proizvoljan i naročito treba voditi računa o sledećem: ako se u dva rukovaoca nalaze parametri iz klasa izuzetaka vezanih nasleđivanjem, tada rukovalac sa klasom-potomkom mora stajati fizički ispred rukovaoca sa pretkom. U suprotnom, zbog polimorfizma, rukovalac sa pretkom prihvatiće kao parametar i potomak, te onaj drugi neće moći nikad da se izvrši. Ulogu univerzalnog rukovaoca koji prihvata sve izuzetke mogu da odigraju rukovaoci sa parametrom iz klasa Throwable ili Exception (obično ove druge), pri čemu se univerzalni rukovalac obavezno navodi kao poslednji. Poslednji deo naredbe try jeste opcioni deo koji počinje rečju finally. Karakteristika ovog bloka jeste da se izvršava uvek, dakle i tada kada se blok try prekida zbog pojave izuzetka. Namena bloka finally je da se, po potrebi, izvrši svojevrsno "pospremanje" (engl. "clean-up"): ako su u okviru bloka try započete neke radnje što se moraju završiti bez obzira na prekid (npr. zauzeti su neki resursi koji se moraju osloboditi), tada se završetak tih radnji smešta u blok finally. Ovog bloka obično nema. Šema izvršavanja naredbe try prikazana je na slici 9.5.

try

izuzetak E

catch catch catch(E e) catch

finally

Slika 9.5. Neka je, na primer, potrebno napraviti tabelarni prikaz vrednosti funkcije f iz ranijih primera, koristeći napred datu metodu printf koja generiše (tačnije prosleđuje) klijentu izuzetak NegativeArgException ako je argument funkcije manji od 0. Neka, dalje, želimo da u slučaju nastanka izuzetka prikaz ne bude prekinut, nego da se umesto vrednosti prikaže tekst NEGATIVAN ARGUMENT!

Da bi se to postiglo, metodu printf treba aktivirati u bloku try i predvideti rukovalac koji će prepoznati i obraditi izuzetak iz klase NegativeArgException. Programski tekst koji ćemo dati sadrži tabelarni prikaz funkcije za vrednosti argumenta složene u vektor y. Uočiti da među vrednostima ima i negativnih.

9. Prevencija otkaza. Obrada izuzetaka

254

public static void main(String args[]) { double[] y = {1,2,-3,4,-5,6}; System.out.println("TABELARNI PRIKAZ FUNKCIJE "+ "2*sin(x)*sqrt(x)\n"); for(int i=0;i
Izvršavanjem metode main dobijamo izlaz oblika TABELARNI PRIKAZ FUNKCIJE 2*sin(x)*sqrt(x) f(1.0) = 1.682941969615793 f(2.0) = 2.5718815064956724 f(-3.0) = NEGATIVAN ARGUMENT! f(4.0) = -3.027209981231713 f(-5.0) = NEGATIVAN ARGUMENT! f(6.0) = -1.3688507936258407

Kako vidimo, nailaskom na negativan argument rad programa se ne prekida nego se izvršava segment predviđen odgovarajućim rukovaocem izuzetkom. Pored postupaka prosleđivanja izuzetka klijentu višeg nivoa, odnosno obrade izuzetka naredbom try, postoji i treći način za rukovanje otkazima što predstavlja kombinaciju prva dva: obrada izuzetka rukovaocem, a zatim prosleđivanje izuzetka klijentu. Ostvaruje se jednostavno, tako što se u blok odgovarajućeg rukovaoca, na kraju obrade izuzetka npr. e, stavi naredba throw e;

Dakle, opšti oblik rukovaoca koji obrađuje i prosleđuje izuzetak jeste catch(ExClass e) { //obrada izuzetka e throw e; }

Naravno, metoda u kojoj se nalazi ovakav rukovalac, pošto prosleđuje izuzetak, mora imati odgovarajuću deklaraciju throws. Primer 9.1. Formiraćemo klasu CharStack sa namenskim, sekvencijalno realizovanim znakovnim stekom u kojem se prevencija otkaza vrši pomoću generisanja izuzetaka. Prvo, do otkaza može doći pri pokušaju očitavanja ili uklanjanja iz praznog steka (tzv."underflow") odnosno prilikom upisa u već popunjen stek ("overflow"). Izuzetke možemo modelovati na više načina: u okviru ovog primera sačinićemo jednu jedinu klasu StackException za generisanje obe vrste izuzetaka koji će se razlikovati samo po poruci što se šalje klijentu prilikom pojave izuzetka. Klasa je jednostavna: StackException.java public class StackException extends RuntimeException { public StackException(String message) { super(message);

9. Prevencija otkaza. Obrada izuzetaka

255

} }

Klasa je izvedena iz klase RuntimeException tako da se izuzeci mogu i ne moraju prihvatati pomoću posebne naredbe try. Osim nasleđenih metoda, klasa ima samo još konstruktor sa obaveznom porukom message po kojoj će se prepoznati da li je u pitanju underflow ili overflow. Jedina naredba u konstruktoru je poziv konstruktora klase RuntimeException sa porukom message. Sama klasa CharStack sadrži standardne operacije nad stekom. Isključivo vežbe radi, umesto dve metode, za očitavanje i uklanjanje, ove operacije realizovaćemo jednom jedinom metodom: tzv. destruktivnim očitavanjem80. Metoda sa nazivom pop ukloniće znak sa vrha steka i vratiti ga kao rezultat. Rizične metode u klasi su pop i push. Metoda pop može da se izvrši samo ako stek nije prazan i to se proverava. Ako taj uslov nije ispunjen, generiše se izuzetak iz klase StackExceptions sa porukom "STACK UNDERFLOW". Metoda push izvršava se pod uslovom da u steku ima mesta. Neka je c kapacitet steka, a t indeks vrha steka. Stek je pun tada kada važi t=c-1. U tom slučaju, metoda push generiše izuzetak sa porukom "STACK OVERFLOW". Konačno, tu je i metoda isEmpty() koja može da zatreba ako je neophodno izvesti sistematsko pražnjenje steka. CharStack.java public class CharStack { private int c,t; private char s[];

'x'

'a'

public CharStack(int c) { t= -1; this.c= c; s= new char[c]; } public char pop() { if(t<0) throw new StackException("STACK UNDERFLOW"); return s[t--]; } public void push(char z) { if(t==c-1) throw new StackException("STACK OVERFLOW"); s[++t]= z; } public boolean isEmpty() { return t<0; } }

Pošto klasa StackException nasleđuje klasu RuntimeException, objekti klase CharStack mogu se koristiti normalno, bez ikakvog dodatnog koda. U slučaju da tokom izvršenja nekog programa koji koristi takav stek dođe do izuzetka, program se prekida sa jednom od dve poruke predviđene metodama pop i push. S druge strane, ako ne želimo da dođe do prekida programa, metode ćemo aktivirati u okviru bloka try sa odgovarajućim rukovaocem. Jedan takav primer bi bio: try { //naredbe koje koriste pop i push 80

Dosta često rešenje.

9. Prevencija otkaza. Obrada izuzetaka

256

} catch(StackException ex) { ex.printStackTrace(); }

Ako se u bloku try generiše izuzetak, on se prenosi rukovaocu koji na ekranu prikazuje istorijat sadržaja adresnog steka i, što je najvažnije, program se nastavlja naredbom koja se nalazi iza try (ne prekida se!). Primer 9.2. U prethodnom primeru, način rukovanja izuzecima bio je koncipiran tako da se obe vrste izuzetaka mogu prepoznati ("uhvatiti") jednim rukovaocem. Ako je iz bilo kojih razloga potrebno obezbediti da se izuzeci prepoznaju različitim rukovaocima, možemo postupiti na sledeći način: formiraćemo apstraktnu klasu StackException sa dve izvedene klase, StackUnderflow za potkoračenje i StackOverflow za prekoračenje kapaciteta steka, slika 9.6. RuntimeException

StackException {abstract}

StackUnderflow

StackOverflow

Slika 9.6. Ovakva organizacija obrade izuzetaka omogućuje da se obe vrste izuzetaka uhvate istim rukovaocem (sa parametrom StackException) ili pak da se za dve vrste izuzetaka napišu posebni rukovaoci: rukovalac sa parametrom klase StackUnderflow odnosno rukovalac sa parametrom klase StackOverflow. Navodimo, prvo, kodove klasa izuzetaka: StackException.java public abstract class StackException extends RuntimeException { public StackException(String message) { super(message); } }

StackUnderflow.java public class StackUnderflow extends StackException { public StackUnderflow() { super("STACK UNDERFLOW"); } }

StackOverflow.java public class StackOverflow extends StackException { public StackOverflow() { super("STACK OVERFLOW"); } }

Programski tekst klase CharStack ima sada sledeći oblik: CharStack.java public class CharStack { private int c,t; private char s[]; public CharStack(int c) { t= -1;

9. Prevencija otkaza. Obrada izuzetaka

257

this.c= c; s= new char[c]; } public char pop() { if(t<0) throw new StackUnderflow(); return s[t--]; } public void push(char z) { if(t==c-1) throw new StackOverflow(); s[++t]= z; } public boolean isEmpty() { return t<0; } }

Na bazi ovako uređenog sistema klasa moguće je realizovati tri vrste rukovalaca izuzecima: jedan koji reaguje samo na izuzetke klase StackUnderflow, jedan namenjen izuzecima klase StackOverflow i jedan koji prihvata obe vrste. Dajemo po jedan primer za svaki (ilustracije radi, prikazali smo tri različita načina za obradu izuzetka): //Rukovalac izuzetkom za klasu StackUnderflow catch(StackUnderflow und) { und.printStackTrace(); } //Rukovalac izuzetkom za klasu StackOverflow catch(StackOverflow ovr) { System.out.println(ovr.getMessage()); } //Rukovalac za obe vrste izuzetaka catch(StackException both) { System.out.println(both); }

10. ULAZNO-IZLAZNI PODSISTEM Svaki programski sistem opšte namene neizostavno sadrži podsistem za razmenu podataka sa raznim uređajima: ekranom, tastaturom, diskom itd. Java u tom pogledu nije izuzetak. Ulazno-izlazni podsistem smešten je u paket java.io i zasnovan je na dva principa: 1. Prvi princip Alena Keja (više puta pominjani "Sve je objekat") što nalaže da se UI podsistem realizuje kao hijerarhija klasa. 2. Ulazno-izlazne operacije treba da budu maksimalno nezavisne od karakteristika konkretnog uređaja i uniformne za uređaje sličnih karakteristika. Temelji na kojima je zasnovan javin UI podsistem očigledno su pouzdani i nisu originalni. Međutim, oživotvorenje navedenih principa, već podleže diskusiji. Naime, konkretizacija hijerarhije UI klasa zasnovana je na sledećoj ideji: 

Apstrakcije što modeluju ulaz razdvajaju se od apstrakcija koje modeluju izlaz, tako da se UI sistem faktički sastoji od dve hijerarhije: jednu čine ulazne, a drugu izlazne klase.

Ma koliko i ovo delovalo logično i razumljivo, u realizaciji se pokazalo da je rezultat komplikovan UI podsistem. Ekel [Ec97] primećuje da je kriterijum za razdvajanje UI klasa zasnovan samo na smeru toka podataka, nedovoljan da bi opravdao dve hijerarhije, budući da nije uzet u obzir i način komunikacije sa UI uređajima. Razmena podataka sa uređajima može biti zasnovana na pojedinačnim bitovima-bajtovima (dakle, bez semantike), ali i na znakovima i stringovima, dalje može biti formatirana i najzad može biti dvosmerna kada se radi o datotekama na disku. Dodatni problem što opterećuje realizaciju UI podsistema jeste prelazak sa osmobitnih znakova na šesnaestobitne. Sve ovo navodimo ne da bismo se upuštali u kritičku analizu javinog UI podsistema nego prosto da čitalac ne bi došao u situaciju da (kako to Ekel navodi) posumnja u svoje sposobnosti razumevanja ovog dela jave. U ranijim poglavljima već smo se susreli sa metodama i klasama sa više verzija koje su simultano u upotrebi, poput recimo klasa Enumeration i Iterator. Kada je u pitanju UI podsistem, ova pojava je daleko najizraženija: java raspolaže sa dve verzije čitavog podsistema koje su obe u upotrebi i između kojih ima preklapanja. Da konfuzija bude veća, postoje čak i klase sa ulogom posrednika između dve verzije! Verzije se najviše razlikuju u internom kodu (što nije od interesa za programera), ali nažalost i po nazivu većine klasa, pa i njihovih metoda. Pošto su te, vidljive, razlike velike, a obe verzije su u upotrebi, prinuđeni smo da u okviru ovog poglavlja obradimo i jednu i drugu. Starija verzija je terminološki (sic!) izgrađena oko apstraktnog toka (engl. "stream"), dok novija u osnovi ima apstraktni uređaj čitač-pisač ("reader" odn. "writer") koji se vezuje za tok. Pored pomenutih hijerarhija, u standardna sredstva UI podsistema ulaze i dve nezavisne klase: klasa File sa podacima o

10. Ulazno-izlazni podsistem

259

datotekama-direktorijumima i klasa RandomAccessFile što modeluje obične ulazno-izlazne datoteke sa proizvoljnim pristupom.

10.1. KLASA FILE Iako je klasa File nezavisna klasa, počećemo sa njom, jer učestvuje u kreiranju svih vrsta objekata vezanih za datoteke. Pre svega, naziv klase izaziva zabunu, naročito kod programera naviknutiih na procedurne jezike tipa paskala ili C-a u kojima "file" označava datoteku. Objekti tipa File zaista sadrže podatke o datoteci - sve osim njenog sadržaja. Za one koji bliže poznaju datotečne sisteme, radi se o podacima iz zaglavlja ("header") datoteke: identifikator datoteke, veličina datoteke, adresa i još niz drugih podataka. Dodatnu konfuziju unosi i definicija klase File data u dokumentaciji, gde se objekti te klase nazivaju apstraktnim putanjama. Objašnjenje, u stvari, nije komplikovano: u operativnim sistemima, već odavno, datoteke se jednoznačno identifikuju putanjama uračunavajući i ime sa ekstenzijom. Putanja se u procedurnim programskim jezicima zadaje po pravilu kao string koji sadrži naziv logičke jedinice i sekvencu naziva direktorijuma koji vode ka onom u kojem se datoteka nalazi. Poslednji element te sekvence je ime datoteke praćeno ekstenzijom. U sistemu DOS - Windows takav string izgleda ovako: "c:\My Documents\Java Files\New Project\MyFile.dat"

Način zadavanja putanje putem stringa veoma je sličan i u drugim operativnim sistemima, ali ima minornih razlika. Jedan od zadataka klase File - i zato se njeni objekti nazivaju apstraktnim putanjama - jeste da obezbedi da se sve putanje tretiraju jednako, bez obzira na operativni sistem. Dakle, objekti klase File imaju primarnu namenu da budu objektna varijanta putanje. Pri tom, ne pravi se razlika između datoteke i direktorijuma (foldera), tako da objekti File mogu odgovarati i jednima i drugima. Prema tome, datoteke odn. direktorijumi u javi mogu se identifikovati na dva načina: putanjom kao stringom ili kao odgovarajućim objektom klase File. Logično, objekat se jednom vezuje za datoteku ili direktorijum i ne može se izvršiti redirekcija. S obzirom na to da klasa File ima priličan broj raznovrsnih metoda, dok string kao putanja služi samo za identifikaciju, objektno rešenje je moćnije i fleksibilnije. Pošto ovi objekti već identifikuju datoteku-direktorijum time što se, u stvari, vezuju za njihova zaglavlja, normalno je da raspolažu dosta velikim brojem metoda kojima se čitaju podaci iz zaglavlja i čak omogućuju neke jednostavne operacije poput, recimo, kreiranja nove datoteke ili brisanja datoteke-direktorijuma. Od konstruktora kojima klasa raspolaže izdvajamo tri: File(String pathName); File(String parent,String child); File(File dirObj,String fileName);

Prvi konstruktor kreira objekat na bazi putanje datoteke koja obuhvata i njen naziv. Naravno, ako se kreira objekat što odgovara direktorijumu naziva datoteke nema. Pri tom, putanja može biti apsolutna (od korena) ili relativna u odnosu na direktorijum programa iz kojeg je izdata odgovarajuća naredba. Drugi konstruktor omogućuje da se putanja proizvoljno razdvoji na dva dela: jedan se naziva parent, a drugi child i zajedno, konkatenacijom, daju putanju. Obično se za parent navodi putanja do direktorijuma datoteke, a kao child samo ime datoteke. Ovo naravno nije obavezno. Konačno, treći konstruktor kreira objekat na bazi objekta klase File koji predstavlja direktorijum i imena datoteke. Svi pominjani stringovi mogu biti prazni. I još jedna napomena: kada se koristi DOS-Windows notacija, u oznaci putanje, znak \ mora se zameniti eskejp-sekvencom \\. Dakle, ne "c:\dir1\dir2" nego "c:\\dir1\\dir2". S druge strane, ako i u Windows sistemu koristimo notaciju UNIX-a tipa "c:/dir1/dir2", to će biti korektno prevedeno uz automatsku zamenu simbola / simbolom \. Neka je Testfajl.txt datoteka koja se nalazi u direktorijumu d:\My Documents 2\Java knjiga\Nova glava\Primeri

10. Ulazno-izlazni podsistem

260

Sve naredbe koje slede kreiraće nov objekat klase File i vezaće ga za ovu datoteku: File f1 = new File("Testfajl.txt"); File f2 = new File("d:/My Documents 2/Java knjiga/Nova glava/Primeri", "Testfajl.txt"); File f3 = new File("d:/My Documents 2/Java knjiga", "Nova glava/Primeri/Testfajl.txt"); File d = new File("d:/My Documents 2/Java knjiga/Nova glava/Primeri"); File f4 = new File(d,"Testfajl.txt");

Umesto znaka / mogli smo unutar stringa upotrebiti i eskejp-sekvencu \\. Klasa File poseduje velik broj metoda od kojih se neke pojavljuju u dve verzije: jedna operiše stvarnom putanjom u vidu stringa, a druga apstraktnom putanjom iz klase File (takav je slučaj sa metodama list odn. listFile). Pošto su verzije koje operišu apstraktnim putanjama novije i znatno jednostavnije za upotrebu, navodićemo uglavnom samo njih, a čitalac uvek može da se informiše o analognim verzijama koristeći javinu dokumentaciju. Kratkoće radi, u napomenama ćemo umesto "apstraktna putanja" koristiti skraćenicu AP. Takođe, skraćenicom datdir označavaćemo "datoteka ili direktorijum". Kao i do sada, metode nasleđene od klase Object poput equals, getClass ili clone nećemo posebno navoditi. Metode navodimo abecednim redom, onako kako se pojavljuju u odgovarajućoj dokumentaciji. boolean boolean boolean boolean boolean File String String String

canRead() canWrite() createNewFile() delete() exists() getAbsoluteFile() getAbsolutePath() getName() getParent()

File String boolean boolean boolean boolean long

getParentFile() getPath() isAbsoulte() isDirectory() isFile() isHidden() lastModified()

long File[]

length() listFiles()

File[]

listFiles(FileFilter f)

boolean

mkdir()

Dozvoljeno čitanje? Dozvoljen upis? Kreira datoteku (ako već ne postoji) i vezuje za AP Uništava datdir vezan za AP Postoji li datdir vezan za AP? Vraća apsolutnu AP u vidu objekta Vraća apsolutnu putanju u vidu stringa Vraća naziv datdir Vraća parent (videti odgovarajući konstruktor) u vidu stringa Vraća parent kao objekat Konvertuje AP u klasičnu putanju tipa stringa Apsolutna AP? (za razliku od relativne) Da li je direktorijum? Da li je datoteka? Da li je skriveni (sistemski) AP? Trenutak poslednje promene u ms računat od 01.01.1970. Veličina AP u bajtovima Niz sa dirdat koje čine sadržaj direktorijuma zadatog sa AP Niz sa dirdat iz AP koje zadovoljavaju kriterijum zadat parametrom f iz klase FileFilter (videti primer) Kreiranje direktorijuma zadatog sa AP

10. Ulazno-izlazni podsistem

261

Primer 10.1. Ilustrovaćemo neke od metoda klase File na primeru prikaza podataka o datoteci Testfajl.txt koju smo upotrebili kao ilustraciju za konstruktore (videti gore). Programski kod ima sledeći izgled. import java.io.*; class FileInfo { public static void main(String args[]) { //Izdavanje podataka o datoteci File f = new File("Testfajl.txt"); System.out.println("File name: "+f.getName()); System.out.println("Absolute path: "+f.getAbsolutePath()); System.out.println("Path: "+f.getPath()); System.out.println("Parent: "+f.getParent()); System.out.println("Length: "+f.length()); System.out.println("Last modified: "+f.lastModified()); System.out.println("Exists: "+f.exists()); System.out.println("Is directory: "+f.isDirectory()); System.out.println("Is file: "+f.isFile()); } }

Aktiviranje ovog programa generiše sledeći izlaz: File name: Testfajl.txt Absolute path: D:\My Documents 2\Java knjiga\Nova glava\Primeri\Testfajl.txt Path: Testfajl.txt Parent: null Length: 608 Last modified: 1115919688953 Exists: true Is directory: false Is file: true

Primer 10.2. Kako smo rekli, apstraktna putanja odgovara datoteci, ali i direktorijumu. Dakle, objektom klase File moguće je identifikovati i direktorijum te, shodno tome, pročitati njegove različite atribute. Jedan od tih atributa je sadržaj direktorijuma kojeg čine datoteke i drugi subdirektorijumi. Sadržaj direktorijuma dobija se metodom listFiles() koja generiše niz sa elementima tipa File. Svaki element tog niza odgovara nekoj datoteci ili subdirektorijumu što pripadaju posmatranom direktorijumu, tj. onom kojem je pridružena apstraktna putanja. Pošto je svaki element niza opet tipa File odgovarajućim metodama iz te klase mogu se pročitati i atributi datoteka i subdirektorijuma. Inače, u klasi File postoji i metoda list() koja obavlja isti posao kao listFiles(), ali za izlaz daje samo niz stringova sa opisom sadržaja direktorijuma te, kao takva, pruža manje mogućnosti81. Napravićemo program za ilustraciju dve mogućnosti. Jedna je jednostavan prikaz sadržaja direktorijuma c: u kojem se, uz svaki element, navodi da li je u pitanju datoteka ili direktorijum. Drugi segment programa ilustruje upotrebu filtera za formiranje niza File-ova kojim se iz sadržaja direktorijuma biraju samo oni elementi koji zadovoljavaju zadati kriterijum. Za to služi poseban interfejs nazvan FileFilter (postoji i string-varijanta FileNameFilter). Interfejs se sastoji od jedne jedine metode sa zaglavljem boolean accept(File abspath)

gde je abspath objekat klase File (apstraktna putanja). Metoda se operacionalizuje tako da vrati vrednost true kada argument zadovoljava postavljeni kriterijum. Na primer, ako hoćemo 81

Radi se o starijoj verziji metode.

10. Ulazno-izlazni podsistem

262

da kriterijum definišemo kao "je direktorijum" tada implementacija pomenutog interfejsa ima oblik class DirsOnly implements FileFilter { public boolean accept(File pathname) { return pathname.isDirectory(); } }

gde metoda vraća true ako i samo ako je argument direktorijum. Prilikom izvršavanja metode listFiles(FileFilter f) metoda accept aktivira se automatski svaki put kada element treba uključiti u izlazni niz. Element se uključuje u izlaz ako i samo ako accept vrati vrednost true. import java.io.*; class DirInfo { public static void main(String args[]) { File dir = new File("c:"); //Listanje sadrzaja direktorijuma System.out.println("SADRZAJ DIREKTORIJUMA C:"); File f[] = dir.listFiles(); for(int i=0;i
Evo jednog primera izlaza iz gornjeg programa: SADRZAJ DIREKTORIJUMA C: .metadata (DIRECTORY) audio (DIRECTORY)

10. Ulazno-izlazni podsistem

263

AUTOEXEC.BAT (FILE) boot.ini (FILE) BORLANDC (DIRECTORY) BP (DIRECTORY) CLDMA.LOG (FILE) CONFIG.SYS (FILE) DN (DIRECTORY) Documents and Settings (DIRECTORY) INSTALL (DIRECTORY) IO.SYS (FILE) Language (DIRECTORY) MSDOS.SYS (FILE) NTDETECT.COM (FILE) ntldr (FILE) pagefile.sys (FILE) Program Files (DIRECTORY) RECYCLER (DIRECTORY) System Volume Information (DIRECTORY) TP6 (DIRECTORY) TREEINFO.WC (FILE) UTIL (DIRECTORY) VideoSec (DIRECTORY) WINDOWS (DIRECTORY)

DIREKTORIJUMI U DIREKTORIJUMU C: .metadata audio BORLANDC BP DN Documents and Settings INSTALL Language Program Files RECYCLER System Volume Information TP6 UTIL VideoSec WINDOWS

DATOTEKE U DIREKTORIJUMU C: AUTOEXEC.BAT boot.ini CLDMA.LOG CONFIG.SYS IO.SYS MSDOS.SYS NTDETECT.COM ntldr pagefile.sys TREEINFO.WC

10.2. UPRAVLJANJE ULAZOM-IZLAZOM PREKO TOKOVA Starija verzija UI podsistema izgrađena je terminološki oko pojma toka, što se lako uočava budući da se odgovarajući izraz "stream" pojavljuje u imenima praktično svih takvih klasa. Osnovni elementi podsistema su dve hijerarhije, jedna za ulaz i druga za izlaz čije su

10. Ulazno-izlazni podsistem

264

korene klase redom InputStream i OutputStream. Izložićemo ih redosledom prvo izlazni, pa onda ulazni tokovi, jednostavno zato što čitanju podataka prethodi njihov upis. 10.2.1. Izlazni tokovi Hijerarhija izlaznih tokova zamišljena je tako da u korenu ima apstraktnu klasu sa nazivom OutputStream. Pošto je klasa apstraktna, programer ne može da je instancira, što je i logično budući da je za ostvarivanje izlaza neophodno navesti odredište podataka. Odredište podataka koji se prenose precizira se izborom jedne od klasa koje su neposredno izvedene iz klase OutputStream. Odredišta izlaznih podataka, tj. uređaji u širem smislu reči predstavljeni su sledećim klasama izvedenim iz klase OutputStream: 1. Klasa FileOutputStream služi za upis podataka u datoteku na periferijskoj memoriji. Upis se vrši bajt po bajt. 2. Klasa ByteArrayOutputStream za upis u niz bajtova u operativnoj memoriji. Upis se vrši takođe bajt po bajt. 3. Klasa StringBufferOutputStream koja se ne koristi jer je proglašena za "deprecated" (kao i odgovarajuća ulazna klasa StringBufferInputStream). Razlog je činjenica da se stringovi sastoje od znakova koji su u međuvremenu postali šesnaestobitni. Obe pomenute klase zamenjene su odgovarajućim klasama iz novije hijerarhije, nazvanim StringWriter odn. StringReader. 4. Klasa PipedOutputStream za prenos podataka između dva potprocesa u javinom segmentu konkurentnog programiranja. Da bi se ostvarila veza za razmenu podataka između predajnika i prijemnika, na predajnik se vezuje objekat klase PipedOutputStream, a zatim se objekat PipedInputStream "nastavlja" na prvi82 ostvarujući tako kanal za protok podataka. 5. Klasa SequenceOutputStream za kombinovanje dva izlazna toka ili više njih u jedan. 6. Klasa ObjectOutputStream za upis objekata na tok. Klase raspolažu približno istim metodama među kojima treba izdvojiti razne varijante metoda write za upisivanje, kao i metodu close() za zatvaranje toka. Najširu primenu ima klasa FileOutputStream koja se vezuje za datoteku. Između klasa izvedenih iz OutputStream izdvaja se još klasa FilterOutputStream jer ima drukčiju namenu od ostalih. Radi se o klasi koja je koren subhijerarhije klasa sa posebnom namenom da dodaju semantiku objektima iz ostalih klasa. Na primer, objekat klase FileOutputStream može se vezati za datoteku na disku. U tom, sirovom, obliku ulaz iz datoteke organizuje se na nivou bajta, bez semantike. Klasa DataOutputStream služi upravo za to da se ulazni podaci formatiraju, tj. da se bajtovi grupišu tako da formiraju podatke tipa npr. char, int, double i sl. Klasa BufferedOutputStream opet funkcioniše nad datotekom tako što omogućuje da se izlaz baferiše, tj. da se podaci ne upisuju u datoteku jedan po jedan, nego da se jednim pristupom iz memorijskog bafera prebaci na disk više podataka odjednom, ubrzavajući tako operaciju izlaza. Iz klase FilterInputStream izvedene su sledeće klase: 1. Klasa DataOutputStream za formatirani izlaz na tok. 2. Klasa BufferedOutputStream za baferovani izlaz. 3. Klasa PrintStream što služi, kao i klasa DataOutputStream, za formatirani izlaz, ali prevashodno na ekran. Statičko polje out u klasi System koje smo koristili u više navrata nije ništa drugo do objekat klase PrintStream.

82

Otud i naziv "pipe" sa značenjem "vodovodna cev".

10. Ulazno-izlazni podsistem

265

OutputStream {abstract} FilterOutputStream

FileOutputStream

DataOutputStream

SequenceOutputStream

ByteArrayOutputStream

PipedOutputStream

BufferedOutputStream

PrintStream

ObjectOutputStream

Slika 10.1. Na slici 10.1 prikazana je hijerarhija izlaznih tokova. Pošto će se većina klasa pojaviti u novijoj varijanti, osvrnućemo se bliže na klasu DataOutputStream koja se koristi u obe varijante UI podsistema. Klasa raspolaže jednim konstruktorom DataOutputStream(OutputStream out)

što znači da za argument može da primi bilo koji objekat hijerarhije. Na taj način omogućuje se određeni nivo formatiranja za bilo koje odredište podataka. Način na koji se to radi primenjuje se i kod drugih klasa i dosta je karakterističan. Za dodavanje funkcionalnosti ili semantike koriste se ugneždeni konstruktori i to tako što konstruktor koji dodaje funkcionalnost kao da "obavija" onaj na koji se oslanja. Neka je, na primer, potrebno obezbediti formatirani, baferovani izlaz podataka u datoteku Data.dat. Prvo, odgovarajući objekat klase FileOutputStream kreiraćemo konstruktom new FileOutputStream("Data.dat")

Zatim ćemo kreirani objekat iskoristiti kao argument za konstruisanje baferovane izlazne datoteke: new BufferedOutputStream( new FileOutputStream("Data.dat"))

Konačno, "obavijanjem" ovog objekta (u stvari, korišćenjem kao argumenta) kreiraćemo traženi objekat klase DataOutputStream: new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.dat")));

Čitava naredba za kreiranje objekta npr. out ima karakterističan, lako uočljiv oblik: DataInputStream out= new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.dat")));

Na ovom mestu, osvrnućemo se na još jednu izuzetno važnu osobinu UI operacija. Poznato je, naime, da su one veoma podložne raznim greškama i da su, pri tom, posledice tih grešaka po pravilu izrazito neprijatne. Usled toga,

10. Ulazno-izlazni podsistem



266

metode u okviru UI klasa svih vrsta po pravilu generišu izuzetke i to klase IOException ili iz nje izvedenih klasa (ima ih dosta). Usled toga, metode se najčešće primenjuju u okviru naredbe try.

Već i sama naredba za konstruisanje objekta in, data napred, mora se izvesti uzimajući u obzir činjenicu da se u okviru konstruisanja generiše izuzetak. Ne ulazeći u precizan opis izuzetka, zadovoljićemo se prihvatom na bazi klase IOException. Dakle, naredba za kreiranje objekta in mora uzeti u obzir i izuzetak: try { DataInputStream out= new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.dat"))); //koriscenje toka out } catch(IOException ioerr) { //ovde se moze naci npr. ioerr.printStackTrace(); //ili cak nista }

Kako smo videli u prethodnom poglavlju, blok try nije jedino rešenje: ako iz bilo kojih razloga ne želimo da koristimo ovu naredbu, izuzetak možemo uvek preneti klijentu višeg nivoa deklaracijom throws. U zaglavlju metode u kojoj se kreira objekat in tada stoji deklaracija throws IOException

Dajemo nekoliko važnijih metoda klase DataOutputStream. int void

size() close()

void

flush()

void void void

write(int i) writeBoolean(boolean b) writeByte(int i)

void void void void void void void void

writeBytes(String s) writeChar(int c) writeChars(String s) writeDouble(double d) writeFloat(float f) writeInt(int i) writeLong(long l) writeShort(Short s)

Broj bajtova koji su već upisani na tok. Zatvaranje toka. Preuzeta iz klase OutputStream. Postoji u svim izlaznim tokovima. Upisivanje preostalog sadržaja privremenog bafera na tok (tzv. "flašovanje"). Upis nižeg bajta argumenta i na tok Upis podatka tipa boolean Upis byte podatka (tj. upis int podatka kao byte) Upis stringa kao niza bajtova Upis int podatka kao char, prvo viši bajt Upis stringa kao niza znakova Upis double podatka Upis float podatka Upis int podatka Upis long podatka Upis short podatka

U dokumentaciji jave postoji precizan opis formata u kojem podaci moraju biti zapisani da bi se mogli kasnije učitati odgovarajućim metodama ulaznih klasa, pri čemu ti formati nisu

10. Ulazno-izlazni podsistem

267

trivijalni. Na svu sreću, standardni način upotrebe ovih metoda nije zasnovan na poznavanju detalja zapisa: dovoljno je da podaci budu upisani metodama iz klase DataOutputStream, pa da formatiranje i deformatiranje bude implicitno. Na primer, podatak tipa double upisuje se na tok metodom writeDouble(), a da bi bio korektno pročitan dovoljno je upotrebiti metodu readDouble() iz klase DataInpitStream. Pošto za svaku metodu za upis u klasi DataOutputStream u klasi DataInputStream postoji odgovarajuća metoda za čitanje, formatizovani ulaz-izlaz, u stvari, ne predstavlja nikakav problem. Primer 10.3. Sledeći program će upisati podatke tipa double u datoteku Data.dat koja se nalazi na disku. Obratiti pažnju na definiciju datoteke i upotrebu naredbe try. Output.java import java.io.*; class Output { public static void main(String args[]) { try { DataOutputStream out= new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.dat"))); out.writeDouble(1.1); out.writeDouble(2.2); out.writeDouble(3.3); out.writeDouble(4.4); out.writeDouble(5.5); out.close(); } catch(IOException ioerror) { ioerror.printStackTrace(); } } }

10.2.2. Ulazni tokovi Hijerarhija ulaznih tokova zamišljena je tako da su skoro svi upareni sa izlaznim, tako da podatak upisan nekom od metoda izlazne klase može da se učita odgovarajućom metodom ulazne klase. Korena klasa ulazne hijerarhije je apstraktna klasa InputStream. Iz nje se neposredno izvode klase po čijim se nazivima lako ustanovljava kojim izlaznim klasama odgovaraju: 1. Klasa DataInputStream za formatirani ulaz sa toka. 2. Klasa BufferedInputStream za baferovani ulaz. 3. Klasa LineNumberInputStream prvobitno namenjena za praćenje broja učitanih linija. Kao i druge klase zasnovane na ulazu znakova ne koristi se zbog promene kodnog sistema. 4. Klasa PushbackInputStream koja omogućuje da se već učitani podatak vrati na tok. U tu svrhu koristi se posebna grupa metoda s zajedničkim nazivom unread. Hijerarhija sa klasama koje modeluju ulazne tokove prikazana je na slici 10.2. Kako vidimo, i u ulaznoj hijerarhiji postoji klasa FilterInputStream za filtriranje ulaza, tj. za dodavanje specijalnih osobina. Ima nekih sitnijih razlika koje potiču od smera razmene podataka (upis ili čitanje). Tako, nema klase koja bi odgovarala klasi PrintStream jer ni ne može da postoji, ali zato postoji tipična ulazna klasa PushbackInputStream kod koje se učitani bajt može vratiti na tok ako je to potrebno. Metode u svim klasama su u najvećoj meri dualne sa metodama u izlaznim klasama, s tim što se ovde umesto reči write u metodama pojavljuje read. Način za kreiranje objekata "obavijanjem" konstruktora isti je kao i kod izlaza.

10. Ulazno-izlazni podsistem

268

InputStream {abstract} FilterInputStream

SequenceInputStream

FileInputStream

DataInputStream

ByteArrayInputStream

BufferedInputStream

PipedInputStream

ObjectInputStream

PushBackInputStream

Slika 10.2. Dakle, ako hoćemo da kreiramo objekat klase DataInputStream koji se vezuje za datoteku Data.dat iz prethodnog primera, to ćemo izvesti segmentom try { DataInputStream in= new DataInputStream( new BufferedInputStream( new FileInputStream("Data.dat"))); //koriscenje toka in } catch(IOException ioerr) { //ovde se moze naci npr. ioerr.printStackTrace(); }

Vidimo da se i ovde mora voditi računa o obradi izuzetaka koja je jednako zastupljena kao i kod izlaznih tokova. Pošto se ulazni tokovi pojavljuju u obliku čitača (reader) u novijoj verziji, dajemo izbor iz sadržaja klase DataInputStream koja se, kao i DataOutputStream, koristi u obe verzije: int void boolean byte char double float int long short String

available() close() readBoolean() readByte() readChar() readDouble() readFloat() readInt() readLong() readShort() readLine()

Broj bajtova na toku koji još nisu pročitani. Preuzeta iz klase InputStream. Postoji u svim ulaznim tokovima. Zatvaranje toka. Preuzeta iz klase InputStream. Postoji u svim ulaznim tokovima. Čitanje podatka tipa boolean Čitanje byte podatka Čitanje char podatka Čitanje double podatka Čitanje float podatka Čitanje int podatka Čitanje long podatka Čitanje short podatka Koristila se za čitanje linije iz tekstuelne datoteke. Više se ne koristi.

10. Ulazno-izlazni podsistem

269

Primer 10.4. Neka su u datoteku Data.dat upisani double podaci iz primera 10.3. Sledeći program će učitati te podatke i ispisati ih na ekranu: Input.java import java.io.*; class Input { public static void main(String args[]) { try { DataInputStream in= new DataInputStream( new BufferedInputStream( new FileInputStream("Data.dat"))); while(in.available()!=0) System.out.println(in.readDouble()); in.close(); } catch(IOException ioerror) { ioerror.printStackTrace(); } } }

Primer 10.5. Primenu tokova za upis-čitanje datoteka ilustrovaćemo na još jednom jednostavnom primeru. Napravićemo program koji će učitati podatke iz datoteke Tekstfajl.txt, kopirati ih u datoteku Tekstfajl.bkp i prikazati na ekranu. Podaci se prenose bajt po bajt. Pretpostavka je da su podaci zapisani osmobitnim kodom. Samo ilustracije radi, prenos na ekran neće se vršiti pomoću standardnog polja System.out nego formiranjem posebnog toka iz klase PrintStream (ovo u praksi ne bismo radili). Pošto je program jednostavan, nećemo davati dalja objašnjenja. InOutStreams.java import java.io.*; class InOutStreams { public static void main(String args[]) { try { byte b; DataInputStream ulaz= new DataInputStream( new BufferedInputStream( new FileInputStream("Tekstfajl.txt"))); PrintStream ekran= new PrintStream( new BufferedOutputStream(System.out)); DataOutputStream izlaz= new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Tekstfajl.bkp"))); while(ulaz.available()!=0) { b=ulaz.readByte(); //Ucitavanje znaka kao bajta ekran.print((char)b); //Prenos na ekran izlaz.writeByte(b); //Kopiranje u drugu datoteku } ulaz.close();

10. Ulazno-izlazni podsistem

270

ekran.close(); izlaz.close(); } catch(IOException ioerror) { ioerror.printStackTrace(); } } }

10.3. UPRAVLJANJE ULAZOM-IZLAZOM PREKO APSTRAKTNIH UREĐAJA Verzija UI podsistema koju smo upravo izložili izgrađena je oko pojma toka, tj. neke vrste apstraktnog medijuma za prenos podataka. Nova verzija naslanja se na pojam apstraktnog uređaja za upis odn. čitanje, na šta ukazuju novouvedeni nazivi "writer" i "reader". U logičkom smislu, umesto da se ulaz-izlaz vrši direktno nad tokovima, između klijenta i (apstraktnog) toka pojavljuje se posrednik u vidu apstraktnog čitača-pisača preko kojeg se vrše pomenute operacije., slika 10.3. klijent

čitač-pisač

tok

Slika 10.3. Da ne bi bilo nesporazuma: ova promena pogleda na elemente UI podsistema jeste zanimljiva i na neki način originalna, ali ne donosi ništa naročito novo u domenu upotrebe klasa. Lako uočavamo da je bar jedan od razloga za ovu promenu dosta prozaičan: nazivi Writer i Reader daleko su kraći od OutputStream i InputStream što posebno dolazi do izražaja kada se upotrebljavaju kao deo naziva izvedenih klasa - setimo se ByteArrayInputStream! Drugi razlog je svakako upotreba UNICODE-a za predstavljanje znakova. Klase Writer i Reader ne zamenjuju odgovarajuće klase starije verzije u smislu da su ove druge izbačene iz upotrebe (da je tako ne bismo ih ni navodili). Obe verzije su u upotrebi i, štaviše, neke klase poput npr. DataOutputStream koriste se u neizmenjenom obliku. Takođe, uvedene su dve posebne klase OutputStreamWriter i InputStreamReader za konverziju iz starije hijerarhije u noviju, tačnije za kreiranje apstraktnog uređaja na bazi apstraktnog toka. Činjenica da se hijerarhije koriste simultano i da za neke tokove ne postoje analogni uređaji ni u kom slučaju ne doprinosi uprošćavanju UI podsistema. Naprotiv, teško je oteti se utisku da je u ovom trenutku to najkomplikovaniji i najnekvalitetniji podsistem jave. Recimo, za formatirani izlaz u datoteku može da se koristi tok DataOutputStream. Za ulaz se koristi DataInputStream, osim u slučaju kada se čita linija metodom readLine() koja je proglašena za "deprecated". U ovom slučaju mora se kreirati objekat klase BufferedReader, vezati za tok klase DataInputStream i izvršiti učitavanje linije. S druge strane, klasa BufferedReader nema metode za učitavanje baznih tipova kao što je npr. readDouble(), te se tu koristi tok. Na taj način dolazi se u situaciju da se iz iste datoteke čita putem dva objekta: svi podaci osim linije (niza znakova koji se završava sa '\n' ili '\r') čitaju se preko toka, a linija preko baferisanog čitača! Dualizam sredstava za korišćenje UI podsistema ne pojavljuje se samo između dve hijerarhije, nego i unutar samih hijerarhija, a neke klase se čak pojavljuju u obe verzije. Zato je, čini se, najdelotvornije izložiti osnovne osobine UI podsistema prateći ne klase i metode nego postupke: postupak za korišćenje tekstuelnih, znakovnih i drugih datoteka, zatim postupak memorisanja objekata, postupak razmene podataka između dva potprocesa itd. Na taj način ostvarićemo sistematičnost, ali i pokazati da su sami postupci kada se jednom ustanove zapravo relativno jednostavni. Pre nego što pređemo na opis najvažnijih postupaka (neki će biti opisani u drugim poglavljima) dajemo kratak pregled klasa u okviru hijerarhije apstraktnih uređaja.

10. Ulazno-izlazni podsistem

271

Koren izlazne hijerarhije čini apstraktna klasa Writer. Važnije metode u klasi Writer preuzimaju ih sve klase hijerarhije - jesu: void void void

write(int ch) write(String str) write(char[] cBuff)

Upis znaka ch. Upis stringa str. Upis niza znakova cBuff.

Sve metode, uključujući i apstraktne koje nisu navedene, generišu izuzetke klase IOException. Klasu Writer nasleđuje čitav niz klasa: 1. Klasa BufferedWriter za baferovani izlaz. 2. Klasa CharArrayWriter koja se vezuje za memorijsku znakovnu sekvencu promenljive veličine. Može se pretvoriti u niz znakova metodom toCharArray ili u string metodom toString. 3. Apstraktna klasa FilterWriter koja je baza za izradu klasa što filtriraju znakovne tokove. 4. Konvertor OutputStreamWriter za kreiranje pisača na osnovu toka, tj. za konverziju toka u pisač. U logičkom smislu reči, ova klasa može se shvatiti kao vezna klasa za pisač i tok. Iz nje je izvedena važna klasa FileWriter koja služi za povezivanje datoteka sa pisačima i to prvenstveno sa BufferedWriter. Primena će biti pokazana u sledećem odeljku. 5. Klasa PipedWriter za predaju podataka drugom potprocesu (tzv. niti). Zamenjuje klasu PipedOutputStream. 6. Klasa PrintWriter za formatirani izlaz u tekstuelnu datoteku ili drugi tekstuelni apstraktni uređaj. Zamenjuje klasu PrintOutputStream. 7. Klasa StringWriter za upis znakova u memoriju VM. Po završenom upisu, memorijski segment čita se kao string. Pošto je među navedenim klasama najčešće korišćena klasa BufferedWriter, navodimo izabrane metode iz njenog repertoara:

void void

BufferedWriter(Writer out) write(int ch) close()

void void

flush() newLine()

Konstruktor Upis znaka (redefinisana). Zatvaranje pisača (tačnije, toka na koji se upisuje). Pri zatvaranju vrši se pražnjenje bafera. Pražnjenje bafera bez zatvaranja. Upis separatora što označava kraj linije (za tokove koji sadrže tekst).

Koren ulazne hijerarhije jeste apstraktna klasa Reader sa sledećim sadržajem: int int

read() read)char[] cBuff)

Čitanje jednog znaka. Učitavanje niza znakova. Vraćena vrednost jednaka je broju učitanih znakova.

Iz ove klase izvode se sledeće klase: 1. BufferedReader za baferovani ulaz. Iz nje je izvedena klasa LineNumberReader koja omogućuje pridruživanje brojeva linijama kada se ulaz obavlja iz tekstuelne datoteke. 2. Klasa CharArrayReader je čitač dualan pisaču CharArrayWriter.

10. Ulazno-izlazni podsistem

272

3. Apstraktna klasa FilterReader za filtriranje ulaznih tokova. Iz nje je izvedena konkretna klasa PushBackReader koja omogućuje vraćanje pročitanog znaka ili čak niza znakova natrag na tok (već pominjana operacija "unread"). 4. Klasa InputStreamReader za konverziju toka u čitač. Dualna je klasi OutputStreamWriter. Ima izvedenu klasu FileReader za neposredno povezivanje datoteke sa pisačem. 5. Klasa PipedReader koja, u sprezi sa PipedWriter, obezbeđuje vezu između potprocesa. Analogna je klasi PipedInputStream. 6. Klasa StringReader za čitanje sadržaja memorije upisanog pomoću objekta klase StringWriter. Posebno izdvajamo klasu BufferedReader dualnu klasi BufferedWriter: BufferedReader(Reader in) read() readLine()

Konstruktor int Učitavanje jednog znaka (redefinisana) String Učitavanje linije (za tokove što sadrže tekst). Kada više nema linija za učitavanje vraća se vrednost null. void close() Zatvaranje čitača. U spisku klasa uočavamo dve specifične: konvertore ili vezne klase OutputStreamWriter i InputStreamReader što povezuju apstraktni čitač-pisač sa tokom. Tehnički, ove klase (ili njihove naslednice FileWriter odn. FileReader, za datoteke) vrše konverziju iz klasa što predstavljaju tokove. U logičkom smislu pak one se pojavljuju kao vezne klase koje povezuju apstraktne uređaje sa apstraktnim tokovima, slika 10.4. klijent

čitač-pisač

vezna klasa

tok

Slika 10.4.

10.4. KORIŠĆENJE DATOTEKA Verovatno najviše konfuzije i nedoumica pri korišćenju UI podsistema izaziva rad sa datotekama. Razlog je već navođena Ekelova [Ec97] primedba da prilikom izgradnje obe hijerarhije nije uzet u obzir način komunikacije sa realnim podacima. Ovo najviše dolazi do izražaja upravo pri radu sa datotekama gde se prvo mora praviti razlika između tekstuelnih datoteka, znakovnih datoteka i datoteka sa podacima. Pored toga, datoteka se može obrađivati sekvencijalno (redosledno) od početka ka kraju, ili u proizvoljnom redosledu i sve se to mora imati u vidu prilikom izbora odgovarajućih klasa. Kao ilustraciju problema koji mogu nastati pri nepažljivom rukovanju UI podsistemom pozvaćemo se na primer iz [Ec97, poglavlje 10]. Neka je potrebno u datoteku Data.txt upisati liniju teksta Here's the value of pi:

a zatim i približnu vrednost  jednaku 3.14159. Neka se potom linija čita i prikazuje na ekranu, a iza nje i upisana vrednost (koja je tipa double). Ekel predlaže sledeće rešenje: za upis koristiti tok sa nazivom npr. out, klase DataOutputStream. Na tok se postavlja prvo linija teksta, a zatim i podatak tipa double. Sa čitanjem, stvari stoje nešto drukčije. Zbog kompatibilnosti, linija teksta (koja je string), učitava se apstraktnim uređajem inBR iz klase BufferedReader. Kako u ovoj klasi nema metoda za učitavanje baznih tipova, podatak 3.14159 mora se učitati simultanom primenom toka in iz klase DataInputStream. Odgovarajući program izgleda ovako: import java.io.*; class WriteReadTest {

10. Ulazno-izlazni podsistem

273

public static void main(String args[]) throws Exception { try { //Upis linije teksta i vrednosti u datoteku Data.txt DataOutputStream out= new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.txt"))); out.writeBytes("Here's the value of pi: \n"); out.writeDouble(3.14159); out.close(); //Kreiranje toka za citanje podatka DataInputStream in= new DataInputStream( new BufferedInputStream( new FileInputStream("Data.txt"))); //Kreiranje uredjaja za citanje linije BufferedReader inBR= new BufferedReader( new InputStreamReader(in)); //Citanje linije i prikaz na ekranu ne radi! System.out.println(inBR.readLine()); //Citanje podatka i prikaz na ekranu System.out.print(in.readDouble()); in.close(); } catch(EOFException endf) { System.out.println("End of stream"); } } }

Očekivani izlaz je Here's the value of pi: 3.14159

Međutim, na ekranu će se (bar na jednom java-sistemu) pojaviti izlaz Here's the value of pi: End of stream

što znači da je prilikom čitanja linije čitačem inBR odgovarajući bafer ispražnjen. Porukom in.available() lako se uveravamo da je broj nepročitanih bajtova sa toka in zaista nula! Da bude još interesantnije, ako bismo redosled upisa-čitanja obrnuli, tj. ako bismo prvo upisali podatak, pa onda tekst i pročitali tim redom, na ekranu bi se pojavio očekivani izlaz (!) 3.14159 Here's the value of pi:

Nema potrebe ulaziti u detalje nekompatibilnosti u upravljanju baferom. Naime, greška ne leži (samo) u činjenici da nešto nije u redu sa pražnjenjem bafera koji je zajednički za in i inBR. Uzrok greške nije čak ni to što smo za čitanje iste datoteke koristili dva objekta. Pravi izvor greške je koncepcijske prirode: dobar stil programiranja nalaže da se tekst i podaci ne smeštaju u istu datoteku, a to je upravo urađeno u navedenom primeru! Programski jezici kakvi su paskal ili C imaju potpuno odvojene tipove datoteka koji služe za memorisanje teksta odnosno za memorisanje podataka. U paskalu te vrste datoteka nisu čak ni istog tipa!

10. Ulazno-izlazni podsistem

274

Prema načinu korišćenja, datoteke razvrstavamo u dve grupe. Prvu čine datoteke sa sekvencijalnim (redoslednim) pristupom, a drugu datoteke sa direktnim (proizvoljnim) pristupom ili, kraće, datoteke mogu biti sekvencijalne ili direktne. Sekvencijalne datoteke odlikuju se time što se njihovi elementi obrađuju redosledom u kojem su upisani, dok kod direktnih datoteka redosled obrade nije u korelaciji sa njihovim redosledom u datoteci. Sekvencijalne datoteke dalje delimo na 1. 2. 3. 4.

tekstuelne datoteke čiji su elementi linije teksta, znakovne datoteke čiji su elementi pojedinačni znakovi, binarne83 datoteke sa elementima baznih tipova i datoteke objekata koje će biti objašnjene zajedno sa drugim takvim tokovima u posebnom odeljku..

10.4.1. Korišćenje tekstuelnih datoteka Tekstuelne datoteke sastoje se od znakova koji su složeni u linije što se završavaju posebnim upravljačkim znakom kraja linije. Upravo činjenica da su elementi tekstuelne datoteke linije, razdvaja ih od znakovnih datoteka čiji su elementi pojedinačni znakovi i stoga je manipulacija ovim dvema vrstama datoteka različita. Sam sadržaj linije može biti tekst (kao u dokumentu), ali i konvertovane vrednosti baznih tipova, recimo string "1.5" koji je, u stvari, znakovna predstava broja sa navedenom vrednošću. Prema tome, upis odnosno čitanje tekstuelne datoteke može i ne mora da podrazumeva konverziju podataka u binarni oblik odnosno iz binarnog u tekstuelni oblik. Saobrazno tome, govorimo o upisu-čitanju bez konverzije (kada se prenosi čist tekst) ili sa konverzijom kada se prenose bazne vrednosti sa konverzijom u tekst ili iz obrnuto. Prenos podataka bez konverzije vrši se posredstvom klasa BufferedWriter i BufferedReader. Upis linija vrši se posredstvom objekta klase BufferedWriter. Klasa raspolaže konstruktorom84 BufferedWriter(Writer out)

Veza sa stvarnom datotekom ostvaruje se posredstvom klase FileWriter koja, sa svoje strane, ima konstruktore FileWriter(File f) FileWriter(File f, boolean append) FileWriter(String pathname) FileWriter(String pathname, boolean append)

gde verzije sa parametrom append omogućavaju dodavanje u već postojeću datoteku bez prethodnog uništavanja sadržaja (naravno, kada je append = true). Prema tome, ako želimo da pripremimo upis u datoteku sa nazivom npr. Data1.txt, to možemo izvesti naredbom BufferedWriter out1= new BufferedWriter( new FileWriter("Data1.txt"));

Upis linije vrši se metodom void write(String str) throws IOException

Pri tom, pošto se upisuje string, mora se voditi računa o tome da se linije razdvoje upisivanjem znaka '\n' na odgovarajućem mestu. Neka je, primerice, potrebno u datoteku Data1.txt upisati dve linije teksta. To će se izvesti naredbama 83 84

Naziv je izabran prema terminologiji programskog jezika C. Ovde, kao i u drugim slučajevima, navodimo samo deo metoda koje su od interesa za izlaganje.

10. Ulazno-izlazni podsistem

275

out1.write("This is a text line.\n"); out1.write("Another text line.");

pri čemu je isto bilo moguće izvesti i jednom naredbom out1.write("This is a text line.\nAnother line of text");

Najzad, u klasi BufferedWriter postoji i posebna metoda newLine() kojom se u datoteku upisuje znak za kraj linije (umesto eskejp-sekvence "\n"). Takođe, mora se voditi računa o tome da je upis baferovan i da će biti fizički izvršen kada se bafer popuni. Da bismo se osigurali da će upis biti izvršen, moguće su dve solucije. Ako je upisano sve što je bilo potrebno, datoteka se zatvara naredbom out1.close();

pri čemu se pri zatvaranju bafer prazni (vrši se "flašovanje"). Ako ne želimo zatvaranje datoteke, a hoćemo da se upis izvrši, to se postiže eksplicitnim pozivom odgovarajuće metode: out1.flush();

Rezimirajmo, dakle, kako izgleda segment za upis dve linije teksta u datoteku Data1.txt: try { BufferedWriter out1= new BufferedWriter( new FileWriter("Data1.txt")); out1.write("This is a text line.\n"); out1.write("Another text line."); //Alternativa: // out1.write("This is a text line."); // out1.newLine(); // out1.write("Another text line."); out1.close(); } catch(IOException e) { e.printStackTrace() }

U daljim primerima, zbog jednostavnosti, nećemo navoditi obradu izuzetaka. Po izvršenom segmentu, sadržaj datoteke Data1.txt, pročitan editorom, jeste This is a text line. Another text line.

Linije se učitavaju putem objekata klase BufferedReader. Objekti se kreiraju konstruktorom BufferedReader(Reader in)

Veza sa stvarnom datotekom ostvaruje se preko objekata klase FileReader sa konstruktorima FileReader(File f) FileReader(String pathname)

10. Ulazno-izlazni podsistem

276

Dakle, ako je potrebno pročitati sadržaj datoteke Data1.txt prethodno kreiramo odgovarajući čitač: BufferedReader in1= new BufferedReader( new FileReader("Data1.txt"));

Linije se čitaju metodom String readLine() throws IOException

koja vraća sledeću liniju, odnosno null ako više nema šta da se pročita. Sadržaj datoteke Data1.txt biće u celosti pročitan i obrađen segmentom String s1; while((s1=in1.readLine())!=null) { //obrada linije koja se sada nalazi u stringu s1 }

Po završetku obrade, kao i u svim drugim slučajevima, datoteku treba zatvoriti naredbom in1.close();

Prenos podataka sa konverzijom (zove se i formatirani prenos) podrazumeva mogućnost prenosa linija što se sastoje kako od znakova tako i od podataka baznih tipova, pa čak i objekata. Pri tom, kod upisa vrši se konverzija podataka iz internog oblika u tekstuelnu formu. Na primer, int podatak 10 u memoriji VM ima interni prikaz u formi binarnog broja. Prilikom upisa vrši se konverzija iz tog, binarnog, u tekstuelni oblik koji se sastoji od stringa "10". Pri učitavanju postupak teče u suprotnom smeru: iz tekstuelnog oblika, tj. stringa, vrši se konverzija u interni oblik. Formatirani izlaz može se ostvariti na više načina, a najjednostavniji je korišćenje pisača PrintWriter ili izlaznog toka PrintStream koji, inače, imaju iste metode. Metode smo već koristili prilikom ispisivanja teksta na ekranu i to zato što je standardni izlaz System.out, u stvari, statičko polje tipa PrintStream. Klasa PrintWriter ima četiri konstruktora PrintWriter(Writer out) PrintWriter(Writer out, boolean autoFlush) PrintWriter(OutputStream outs) PrintWriter(OutputStream outs, boolean autoFlush)

Prva dva služe za kreiranje objekta na osnovu pisača, a druga dva za kreiranje na bazi odgovarajućih objekata iz klase OutputStream. Kada se aktivira autoflaš vrednošću true odgovarajućeg parametra, pražnjenje bafera izvodi se svaki put kada se izvrši neka od metoda println. U klasi ima mnogo metoda, ali ih je jednostavno zapamtiti: radi se o preklopljenim metodama print odn. println za izlaz svih baznih tipova, stringova i objekata klasa koje poseduju metodu toString, pri čemu druga grupa podrazumeva upis oznake kraja linije, a prva ne. Metode ne generišu izuzetke. Upotrebu formatiranog izlaza ilustrovaćemo na jednostavnom primeru: neka je potrebno u datoteku Data2.txt upisati prvih 5 prostih brojeva, 2,3,5,7,9 i to tako što će svaki od njih biti upisan u novu liniju. Zadatak će biti obavljen sledećim segmentom: PrintWriter out2= new PrintWriter( new BufferedWriter( new FileWriter("Data2.txt")),true); int primeNumbers[] = {2,3,5,7,9}; for(int i=0;i<5;i++) out2.println(primeNumbers[i]);

10. Ulazno-izlazni podsistem

277

Ako sada editorom pročitamo sadržaj datoteke Data2.txt dobićemo 2 3 5 7 9

Formatirani ulaz neznatno je složeniji jer nema posebne klase za automatsko formatiranje, tako da je programer obavezan da konverziju obezbedi sam. Konverzija podatka baznog tipa iz tekstuelnog u interni oblik vrši se statičkim metodama iz odgovarajućih omotača. Na primer, konverzija tekstuelnog oblika int podatka koji se nalazi u stringu s izvršava se naredbom double d = Integer.valueOf(s).intValue();

Neka se u datoteci Input.txt nalazi ovakav sadržaj: 1.5 12345 Prvi podatak je konstanta tipa double, a u drugoj liniji nalazi se pet int podataka razdvojenih po jednim praznim mestom. Da bi se obavio formatirani ulaz, prvo treba kreirati odgovarajući čitač: BufferedReader in3= new BufferedReader( new FileReader("Input.txt"));

Prvi podatak pročitaćemo segmentom String s3; double d; s3= in3.readLine(); d= Double.valueOf(s3).doubleValue();

Učitavanje niza čije se vrednosti nalaze u drugoj liniji nešto je komplikovanije jer se linija čita odjednom, pa se pojedinačne vrednosti moraju izdvojiti iz učitanog stringa. To se obezbeđuje posredstvom posebne klase sa nazivom StringTokenizer koja se nalazi u paketu java.util. Objekti ove klase omogućuju automatsko razlaganje stringa na sastavne delove, tzv. "tokene", koji su u tekstu međusobno razdvojeni nekim znakom (npr. praznim mestom). U tom smislu, token u običnom tekstu jeste reč, a reči se prepoznaju po tome što su razdvojene praznim mestom, ili tačkom ili tačkom praćenom praznim mestom, nekom od eskejp-sekvenci "\n", "\t" i još nekim. Na osnovu tako definisanih granica, objekat iz pomenute klase omogućuje razlaganje stringa. Inače, razlaganje se odvija mehanizmom iteratora ili, preciznije, sama klasa StringTokenizer implementira klasu Enumeration. Način razlaganja prikazaćemo na gornjem primeru. U drugoj liniji imamo određen broj podataka koji su razdvojeni praznim mestom. Prvo treba tu liniju učitati: s3= in3.readLine();

Objekat klase StringTokenizer kreira se pomoću konstruktora (ne navodimo ih sve) StringTokenizer(String s, String delimiters) StringTokenizer(String s)

10. Ulazno-izlazni podsistem

278

Prvi konstruktor omogućuje da programer sam definiše simbol ili simbole koji razdvajaju tokene, dok drugi oblik koristi podrazumevani skup "\t\n\r\f". Prolazak kroz objekat izvodi se na isti način kao i kod drugih iteratora tipa Enumeration, dakle metodama hasMoreElements() i nextElement(). Po želji, programer može upotrebiti metode hasMoreTokens() i nextToken() koje funkcionišu potpuno isto, ali imaju adekvatnija imena. Pored njih, od važnosti je i metoda countTokens() za određivanje broja tokena na koji je razložen string. Sada možemo pokazati kako će pet brojeva iz datoteke Input.txt biti pročitano pomoću stringa, zatim string razložen na tokene (a to su tih pet brojeva u formi stringa) i najzad kako će se binarni oblici tih pet brojeva složiti u niz sa nazivom niz. import java.util.StringTokenizer; . . . . . s3= in3.readLine(); StringTokenizer strToken = new StringTokenizer(s3," "); int niz[] = new int[strToken.countTokens()]; int n=0; while(strToken.hasMoreTokens()) { niz[n++]= Integer.valueOf(strToken.nextToken()).intValue(); }

Usput, java raspolaže i nešto složenijom klasom StreamTokenizer koja razlaže na tokene čitav tok. Na kraju, potpunosti radi, rećićemo nešto i o tzv. konzolnom ulazu-izlazu. Prvo, pod tim se podrazumevaju izlazne operacije vezane za tzv. standardni izlazni uređaj (najčešće ekran) i ulaz sa standardnog ulaznog uređaja (najčešće tastatura). Konzolni izlaz smo već više puta koristili. Obavlja se preko statičkog polja out koje je objekat klase PrintOutputStream, tako da su primenljive metode print i println. Pored polja System.out postoji i statičko polje System.err istog tipa koje obezbeđuje izlaz na ekran (na out se može primeniti redirekcija). Konzolni ulaz obavlja se preko statičkog polja System.in koje je objekat klase InputStream. Da bi se omogućio ulaz teksta sa konverzijom ili bez nje treba kreirati odgovarajući čitač: BufferedReader in4= new BufferedReader( new InputStreamReader(System.in));

Kako se vidi, morali smo da upotrebimo konvertor InputStreamReader zato što je polje in klase InputStream. Dalje se ulaz obavlja na isti način kao i kod svake druge tekstuelne datoteke. Ako treba učitati liniju teksta bez konverzije primenićemo metodu readLine. Ako je predviđen formatirani ulaz neophodno je obezbediti konverziju: System.out.println("Ukucati double broj"); double dNum = Double.valueOf(in4.readLine()).doubleValue(); System.out.println("\nUkucan je broj: "+dNum);

10.4.2. Korišćenje znakovnih datoteka Znakovna datoteka (engl. "character file") tehnički se ne razlikuje od tekstualne i, štaviše, ista datoteka može se pojaviti u obe uloge. Ipak, razlika postoji, a odnosi se na pogled na datoteku, odn. na način interpretacije njenog sadržaja. Dok se tekstuelna datoteka interpretira kao niz linija, znakovna datoteka je niz znakova. Znakovne datoteke koriste se sasvim jednostavno, primenom klasa BufferedWriter i BufferedReader i njihovih metoda redom void write(int chr) throws IOException int read() throws IOException

//BufferedWriter //BufferedReader

10. Ulazno-izlazni podsistem

279

Prvom metodom se upisuje jedan znak chr u datoteku vezanu uz odgovarajući pisač. Drugom se iz datoteke vezane za čitač učitava jedan znak kao int vrednost. Kada se stigne do kraja datoteke metoda read vraća vrednost -1. Uočimo još jednu stvar: klase BufferedWriter i BufferedReader funkcionišu ne samo sa datotekama nego i sa drugim vrstama tokova. Evo primera upisa znakova 'a',...,'z' u datoteku CharData.dat i njihovog učitavanja, te prikazivanja na ekranu: BufferedWriter out= new BufferedWriter( new FileWriter("CharData.dat")); for(char c='a';c<='z';c++) out.write(c); out.close(); BufferedReader in= new BufferedReader( new FileReader("CharData.dat")); int ch; while((ch=in.read())!=-1) System.out.println((char)ch); in.close();

Znakovi se mogu prenositi pojedinačno ili u grupama, složeni u nizove znakova. Za upis niza znakova, u klasi BufferedWriter predviđena je metoda (nije jedina) void write(char[] cBuff) throws IOException

kojom se znakovni niz upisuje u datoteku. Odgovarajuća metoda za čitanje u klasi BufferedReader jeste metoda (takođe nije jedina) int read(char[] cBuff) throws IOException

Metoda vraća broj učitanih znakova ili -1 ako su pročitani svi. Sledeći segment će učitati podatke iz datoteke CharData iz prethodnog primera. Zapaziti primenu vraćene vrednosti metode read. BufferedReader in1= new BufferedReader( new FileReader("CharData.chr")); int n; char chBuff[]=new char[10];; while((n=in1.read(chBuff))!=-1) { for(int i=0;i
10.4.3. Korišćenje binarnih datoteka Za rukovanje binarnim sekvencijalnim datotekama trenutno ne postoje posebni pisači i čitači. Prema tome, koriste se klasa DataOutputStream i DataInputStream koje su opisane u odeljku 10.2.

10.4.4. Datoteke sa direktnim pristupom Datoteke sa direktnim (proizvoljnim) pristupom (engl. "random access file") jesu klasičan tip datoteka, poznat praktično od pojave diska kao medijuma za čuvanje podataka. Ima ih više vrsta, a ova što se koristi u javi nosi naziv relativna datoteka, jer se njenim elementima pristupa prema poziciji (relativnoj adresi), mehanizmom koji podseća na indeksiranje kod niza. Upravo na primeru te klase, sa nazivom RandomAccessFile, pokazuju se nesavršenosti javinog UI podsistema. Prvo, datoteke sa direktnim pristupom (u daljem tekstu RAF) po pravilu imaju mogućnost istovremenog upisa i čitanja, što je u neskladu sa

10. Ulazno-izlazni podsistem

280

osnovnom koncepcijom UI podsistema, podelom na izlazne i ulazne klase. Pošto nema višestrukog nasleđivanja, klasa nije mogla biti uvrštena u obe hijerarhije, te je, silom prilika, klasa realizovana autonomno, izvan UI hijerarhija, poput klase File. Drugo, RAF se realizuje kao niz bajtova na periferijskoj memoriji, što znači da je osnovna adresibilna jedinica u datoteci 1 bajt. Pristup elementima svake datoteke, pa i RAF, obavlja se na osnovu tekuće pozicije (u javi nazvanoj "file pointer"). Naime, u svakom trenutku, u datoteci (i uopšte na toku) jedna pozicija (bajt) markirana je kao tekuća. Operacije ulaza-izlaza obavljaju se počev od tekuće pozicije. Po završetku UI operacije tekuća pozicija postaje ona koja neposredno sledi poslednju referenciranu. Na slici 10.5 prikazano je stanje pre i posle upisa-čitanja 5 bajtova predstavljenih zasenčenim poljima. Tekuća pozicija označena je blok-strelicom.

write/read

Slika 10.5. Da bi se koliko-toliko uključila u UI podsistem, klasa RandomAccessFile implementira interfejse DataOutput i DataInput, iste one koje implementiraju klase redom DataOutputStream i DataInputStream. Na taj način, bar sa stanovišta operacija, klasa se ponaša istovremeno kao DataOutputStream i DataInputStream. Nažalost, na tome se stvar i završava, jer ih RandomAccessFile ne nasleđuje, te nema mogućnosti upotrebe inkluzionog polimorfizma. Konstruktori u klasi su RandomAccessFile(String pathname,String mode) RandomAccessFile(File f,String mode)

sa namenom da povežu objekat klase RandomAccessFile sa stvarnom datotekom, bilo na osnovu putanje ili odgovarajućeg objekta iz klase File. Drugi parametar predstavlja režim korišćenja datoteke: vrednost "w" znači da se u datoteku može samo upisivati ("write-only"); režim "r" je "read-only", tj. datoteka se može samo čitati; konačno, režim "rw" označava da se datoteka može uporebljavati i za upis i za čitanje. Klasa raspolaže prilično velikim repertoarom drugih metoda od kojih izdvajamo sledeće: void long long void void

seek(long pos) getFilePointer() length() setLength() close()

Postavljanje tekuće pozicije na vrednost pos. Očitavanje tekuće pozicije. Veličina datoteke u bajtovima. Zadavanje veličine datoteke. Zatvaranje datoteke.

Njima treba dodati još niz metoda za upis-čitanje baznih tipova i stringova, koje su iste kao u klasama DataOutputStream i DataInputStream (videti odeljke 10.2.1 i 10.2.2). Tipičan način upisa nekog podatka u datoteku dat obavlja se na osnovu zadate pozicije npr. p. Segmentom dat.seek(p); dat.writeDouble(x);

podatak x tipa double biće upisan na poziciju p u datoteci dat. Po završenom upisu, oznaka tekuće pozicije ostaje na prvom bajtu iza podatka x, u skladu sa slikom 10.5. Sa pozicije p podatak se očitava segmentom

10. Ulazno-izlazni podsistem

281

dat.seek(p); dat.readDouble(y);

gde je y promenljiva tipa double. Oznaka tekuće pozicije pomera se isto kao i kod operacije upisa. Datoteke sa direktnim pristupom, u obliku klase RandomAccessFile, nisu tako moćno sredstvo kako bi se moglo zaključiti na osnovu širine repertoara UI metoda s jedne, i mogućnosti direktnog pozicioniranja s druge strane. Naime, postoji nekoliko problema koji sužavaju područje primene klase u originalnoj formi. Prvo, u istu datoteku mogu se upisivati podaci različitih baznih tipova ili stringovi. Nažalost, takvi podaci nemaju istu dužinu, te se njihova pozicija ne može restaurisati u svrhu čitanja. Otud potiče definiciona osobina klasičnih periferijskih datoteka što podrazumeva da su njihovi elementi po tipu jednoobrazni te, shodno tome, imaju istu dužinu. Time se, međutim, problemi ne iscrpljuju, jer se postavlja pitanje praktične upotrebljivosti datoteke čiji su svi elementi nekog od baznih tipova, recimo datoteke podataka tipa double. U praksi, elementi datoteke nisu jednostavni bazni tipovi nego per se predstavljaju složene strukture podataka - slogove ili zapise. Slog datoteke sadrži polja koja se međusobno razlikuju po tipu, a zajedno sadrže neku informaciju. Na primer, slog datoteke sa podacima o studentu može da sadrži polje sa prezimenom (string), imenom (string), godinom studija (int), brojem indeksa (string ili int) itd. U javi, slog nije bazni tip nego se realizuje kao objekat, a RAF nije namenjena za čuvanje objekata. Primer 10.6. U okviru ovog primera, pokazaćemo kako se može napraviti datoteka sa direktnim pristupom koja bi zadovoljila dva osnovna zahteva: 1. Svi elementi moraju biti istog tipa kako bi se ostvario pristup prema poziciji elemenata, tj. da bi se metodom seek(k) oznaka tekuće pozicije postavila na k-ti element (a ne k-ti bajt) datoteke. 2. U datoteku se mogu upisati ne samo elementi baznih tipova, nego i slogovi što sadrže različita polja. Sredstvo za ostvarivanje ova dva cilja jeste univerzalni nosač podataka - string. Ako realizujemo datoteku čiji su elementi stringovi iste dužine odmah ostvarujemo prvi cilj. Pošto se svi bazni tipovi mogu transformisati u stringove, konkatenacijom takvih stringova postiže se i drugi cilj. Na primer, slog što se sastoji od stringa s, int podatka i i double podatka d pretvara se u string transformacijom toStr = s+"\t"+String.valueOf(i)+"\t"+String.valueOf(d);

gde je "\t" umetnuto kao ograničavač85 za razdvajanje polja. Problem raspakivanja rešavamo objektom klase StringTokenizer koji služi za izdvajanje tri podstringa što odgovaraju poljima s, i i d. Vrednosti pojedinačnih polja dekodiraju se segmentom StringTokenizer st = new StringTokenizer(toStr,"\t"); s= st.nextToken(); i= Integer.valueOf(stk.nextToken()).intValue(); d= Double.valueOf(stk.nextToken()).doubleValue();

U ovom primeru napravićemo RAF čiji su elementi stringovi iste dužine. U primeru iza ovog pokazaćemo kako se na bazi takve datoteke može realizovati RAF sa objektima iste klase, a uz pomoć upravo prikazanih mehanizama za pakovanje-raspakivanje. Shodno novoj UI hijerarhiji, datotekom sa direktnim pristupom i sa slogovima jednake dužine kao elementima, rukovaćemo putem pisača-čitača i zato za odgovarajuću klasu biramo naziv WriterReader. Osnovna RandomAccess datoteka u klasi je realizovana kao polje sa nazivom f. 85

U tu svrhu mogli smo upotrebiti i druge eskejp-sekvence pomenute kod klase StringTokenizer.

10. Ulazno-izlazni podsistem

282

Centralna tačka realizacije jeste bafer charBuffer koji obezbeđuje da se u datoteku upisuju sekvence znakova iste dužine. Klasa String ne može da obezbedi konstantnu dužinu i zato je bafer realizovan kao znakovni niz čija se konstantna dužina buffsize zadaje kao argument prilikom kreiranja objekta. Klasa ima dva konstruktora: public WriterReader(RandomAccessFile rf,int buffsize) throws IOException public WriterReader(RandomAccessFile rf,int buffsize, long length) throws IOException

Prvim se zadaje datoteka na disku koja će sadržati podatke i veličina bafera buffsize (dakle, dužina elemenata datoteke) izražena u znakovima od po 2 bajta. Drugim konstruktorom kreira se datoteka koja ima zadatu veličinu od length elemenata (ne bajtova ili znakova!). Osnovna metoda za upis public void write(String el) throws IOException

realizovana je tako da konvertuje ulazni string el u niz znakova dužine tačno buffsize znakova od po 2 bajta. Ako je string el kraći od bafera dopisuju se znakovi '\u0000'. Posao oko konvertovanja stvarnog sloga u string (pokazali smo ga) prepušta se konkretnom klijentu. Jednostavno rečeno, ako hoćemo RAF sa slogovima, treba napraviti klasu sa metodom za upis koja slog pretvara u string, a zatim string upisuje metodom write u datoteku (videti primer 10.7). Isto važi i za metodu za čitanje public String read() throws IOException

čiji je zadatak da pročitani niz znakova pretvori u string, uz uklanjanje eventualnih znakova '\u0000' na kraju, metodom trim() iz klase String. Metoda read vraća vrednost null ako je prvi znak u baferu '\u0000'. U konkretnoj klasi za korišćenje RAF, treba da se nađe metoda za čitanje koja na osnovu read i ranije opisanog postupka dekodiranja, regeneriše originalni sadržaj sloga. Šema prenosa podataka putem metoda write i read data je na slici 10.6. string

write

string

read

charBuffer

f

buffsize

Slika 10.6. Idejno rešenje sa slike 10.6 ima, međutim, jednu manjkavost vezanu za kvalitet, tačnije za brzinu rada. Naime, upisivanje odnosno čitanje znak po znak je, već kod relativno malih datoteka neprihvatljivo dugotrajan proces. Što se tiče upisa, problem se rešava jednostavno, korišćenjem metode writeChars(String) koja u jednom pristupu upisuje u datoteku ceo string, tj. ceo element. Sve što je potrebno jeste pri upisu pretvoriti sadržaj charBuffer u string. Naredba za upis celog bafera u datoteku f koristi statičku metodu copyValueOf iz klase String koja znakovni niz pretvara u string: f.writeChars(String.copyValueOf(charBuffer));

Čitanje predstavlja nešto veći problem, jer u klasi RandomAccessFile nema metode kojom bi se učitao ceo znakovni niz zadate dužine. Ono što postoji jeste metoda readFully(b) kojom se sekvenca bajtova učitava u niz bajtova b tako da se popuni svaki njegov element. Prema tome,

10. Ulazno-izlazni podsistem

283

mora se obezbediti još jedan bafer tipa niza bajtova, dvostruko duži od charBuffer, koji će prihvatiti element datoteke kao niz bajtova, da bi se onda njegov sadržaj prepakovao u charBuffer spajanjem po dva susedna bajta u šesnaestobitni znak. Ako drugi bafer nazovemo byteBuffer, poboljšana šema prenosa podataka dobija izgled kao na slici 10.6A. string

write

string

read

charBuffer

f

byteBuffer

Slika 10.6A. Datoteka sa direktnim pristupom treba da ima i mogućnost brisanja elemenata. Ovo se u klasi WriterReader ostvaruje metodom public void remove() throws IOException

Element se briše iz datoteke porukom write('\u0000')

čime se u datoteku upisuje element koji sadrži buffsize znakova '\u0000'. Metoda seek(long position) postavlja u datoteci f oznaku tekuće pozicije. Pri tom, mesto position ne odnosi se na bajt (kako je to u RandomAccessFile) nego na element koji je osnovna mera u WriterReader. Metoda getFilePointer() očitava oznaku tekuće pozicije, opet izraženu kao redni broj elementa. Tu je još i metoda length() kojom se očitava broj elemenata datoteke, uračunavajući i prazne elemente ako je bilo brisanja. Metodom close() datoteka f se zatvara, a efekat je taj da se više ne mogu koristiti ni metode klase, kao da je pisač-čitač takođe "zatvoren". Dajemo kompletan kod klase: WriterReader.java import java.io.*; public class WriterReader { private RandomAccessFile f; private char[] charBuffer; private byte[] byteBuffer; //Konstruktor sa zadavanjem velicine bafera public WriterReader(RandomAccessFile rf,int buffsize) throws IOException { charBuffer= new char[buffsize]; byteBuffer= new byte[2*buffsize]; f= rf; } //Konstruktor prazne datoteke sa tacno length elemenata public WriterReader(RandomAccessFile rf,int buffsize, long length) throws IOException { charBuffer= new char[buffsize]; byteBuffer= new byte[2*buffsize]; rf.setLength(2*charBuffer.length*length); //formiranje praznog bafera for(int i=0;i
10. Ulazno-izlazni podsistem

284

rf.write(byteBuffer); f= rf; } //Postavljanje tekuce pozicije //(pozicija je redni broj elementa, a ne bajt!) public void seek(long position) throws IOException { f.seek(position*charBuffer.length*2); } //Ocitavanje tekuce pozicije public long getFilePointer() throws IOException { return f.getFilePointer()/(2*charBuffer.length); } //Upis elementa na tekucu poziciju public void write(String el) throws IOException { int i; if(el.length()>charBuffer.length) throw new IOException("Element too long."); for(i=0;i<el.length();i++) charBuffer[i]= el.charAt(i); for(i=el.length();i
Primer 10.7. Sada ćemo pokazati kako se korišćenjem klase WriterReader može napraviti datoteka sa direktnim pristupom u kojoj se nalaze objekti što modeluju slogove datoteke. Neka je potrebno održavati malu knjigu inventara papirnice (nešto slično primeru 8.5) u kojoj se nalaze stavke sa sledećim sadržajem: 1. Polje invBroj tipa int sa vrednostima od 0 do 999. Polje predstavlja inventarski broj stavke.

10. Ulazno-izlazni podsistem

285

2. Polje String naziv koje predstavlja naziv inventarske stavke i koje ne može biti duže od 50 znakova. 3. Polje int brojKomada koje označava broj komada na lageru. Polje ima najviše 10 znakova (jer je tipa int). Podatke u stavci podesili smo tako da inventarski broj predstavlja istovremeno poziciju u datoteci, uz pretpostavku da na lageru ne može biti više od 1000 različitih vrsta artikala. Na taj način, ostvarili smo jednostavno heširanje bez posebne transformacije u kojem je ključ (inventarski broj) istovremeno i pozicija. Stavka inventara opisana je objektom klase Artikal: Artikal.java import java.io.IOException; public class Artikal { public static final int private int invBroj; private String naziv; private int brojKomada;

MAX_ZNAKOVA=63, BROJ_POLJA=3; //najvise 3 znaka //najvise 50 znakova //najvise 10 znakova

public Artikal() {} public Artikal(int invBroj,String naziv,int brojKomada) throws IOException { if(invBroj>999) throw new IOException("Prevelik inventarski broj."); if(naziv.length()>50) throw new IOException("Predugacak naziv."); this.invBroj= invBroj; this.naziv= naziv; this.brojKomada= brojKomada; } public void set(int invBroj,String naziv,int brojKomada) throws IOException { if(invBroj>999) throw new IOException("Prevelik inventarski broj."); if(naziv.length()>50) throw new IOException("Predugacak naziv."); this.invBroj= invBroj; this.naziv= naziv; this.brojKomada= brojKomada; } public int getInvBroj() { return invBroj; } public String getNaziv() { return naziv; } public int getBrojKomada() { return brojKomada; } }

Inventarsku knjigu realizovaćemo kao klasu ArtWriterReader. Klasa sadrži polje klase WriterReader, a ima osnovni zadatak da obezbedi metode koje će objekat klase Artikal pretvoriti u string i upisati u datoteku, odnosno pročitati iz datoteke i pretvoriti u string. Objekat se konstruiše metodom ArtWriterReader(RandomAccessFile rf) throws IOException

10. Ulazno-izlazni podsistem

286

koja poziva konstruktor br. 2 osnovne klase WriterReader sa zadatom RAF rf i veličinom od 1000 elemenata. Metoda public void write(Artikal art) throws IOException

pretvara stavku art u string i metodom write upisuje je u datoteku na poziciju art.getInvBroj(). Pri tom, za ograničavač je upotrebljen znak '\t', tako da transformacija ima oblik String.valueOf(art.getInvBroj())+ "\t"+art.getNaziv()+ "\t"+ String.valueOf(art.getBrojKomada())

Prilikom čitanja koristi se metoda Artikal read(int invBroj) throws IOException

Postupak je sledeći: prvo se metodom read iz datoteke pročita string sa zadate lokacije. Potom se uz pomoć objekta StringTokenizer string razlaže na tri dela koja odgovaraju poljima objekta Artikal i delovi se dekodiraju. Dekodirana polja upisuju se u objekat res klase Artikal koji se vraća kao rezultat. seek(invBroj); String s = read(); if(s==null) return null; Artikal res = new Artikal(); StringTokenizer stk = new StringTokenizer(s,"\t"); res.set(Integer.valueOf(stk.nextToken()).intValue(), stk.nextToken(), Integer.valueOf(stk.nextToken()).intValue()); return res;

U klasu su uključene još i metoda za brisanje remove koja ima parametar invBroj što definiše poziciju, zatim length koja daje veličinu datoteke (tj. broj 1000) i metoda close koja zatvara pisač-čitač (tačnije, datoteku unutar njega). Dajemo kompletan sadržaj klase: ArtWriterReader.java import java.io.*; import java.util.StringTokenizer; public class ArtWriterReader { private WriterReader wr;; public ArtWriterReader(RandomAccessFile rf) throws IOException { wr= new WriterReader(rf, Artikal.MAX_ZNAKOVA+Artikal.BROJ_POLJA-1, 1000); } public void write(Artikal art) throws IOException { wr.seek(art.getInvBroj()); wr.write(String.valueOf(art.getInvBroj())+"\t"+ art.getNaziv()+"\t"+ String.valueOf(art.getBrojKomada())); } public Artikal read(int invBroj) throws IOException { wr.seek(invBroj);

10. Ulazno-izlazni podsistem

String s = wr.read(); if(s==null) return null; Artikal res = new Artikal(); StringTokenizer stk = new StringTokenizer(s,"\t"); res.set(Integer.valueOf(stk.nextToken()).intValue(), stk.nextToken(), Integer.valueOf(stk.nextToken()).intValue()); return res; } public void remove(int invBroj) throws IOException { if(invBroj>999) throw new IOException("Prevelik inventarski broj"); wr.seek(invBroj); wr.remove(); } public long length() throws IOException { return wr.length(); } public void close() throws IOException { wr.close(); } }

Demonstracioni program za klasu KnjigaInventara: import java.io.*; public class InventarTest { public static void prikazKnjige(ArtWriterReader awr) throws IOException { Artikal art; System.out.println("SADRZAJ KNJIGE:"); for(int i=0;i
287

10. Ulazno-izlazni podsistem

288

System.out.println("\nObrisane stavke sa brojevima 999 i 0."); k0001.remove(999); k0001.remove(0); prikazKnjige(k0001); System.out.println("\nObrisana stavka sa brojem 500."); k0001.remove(500); prikazKnjige(k0001); k0001.close(); } }

Izvršavanje ovog programa generisaće sledeći izlaz: Kreirana prazna knjiga inventara. SADRZAJ KNJIGE: Prikaz zavrsen Upisana stavka sa brojem 0. SADRZAJ KNJIGE: Broj: 0 Naziv: Olovka hemijska Prikaz zavrsen

Komada: 100

Dodate stavke sa brojevima 500 i 999. SADRZAJ KNJIGE: Broj: 0 Naziv: Olovka hemijska Komada: 100 Broj: 500 Naziv: Papir 1000 kom. Komada: 20 Broj: 999 Naziv: Lenjir 0.30m Komada: 50 Prikaz zavrsen Obrisane stavke sa brojevima 999 i 0. SADRZAJ KNJIGE: Broj: 500 Naziv: Papir 1000 kom. Komada: 20 Prikaz zavrsen Obrisana stavka sa brojem 500. SADRZAJ KNJIGE: Prikaz zavrsen

10.5. KORIŠĆENJE MEMORIJSKIH TOKOVA U vezi sa ulazom-izlazom, java ima zanimljivu mogućnost da se strukture u operativnoj memoriji koriste kao neka vrsta datoteka koje se ni po čemu ne razlikuju od standardnih datoteka osim po tome što nisu permanentne. U tom smislu, one se ne mogu koristiti kao sprega između dva nezavisna programa, ali ih mogu referencirati različiti potprocesi u okviru istog programskog sistema, tj. mogu poslužiti za asinhronu razmenu podataka između potprocesa (tzv. "niti", videti poglavlje 11). Realizuju se na dva načina: kao stringovi ili kao nizovi znakova. 10.5.1. String kao memorijski tok Da bi se realizovala i koristila memorijska datoteka koja je izvedena kao string, java predviđa dve klase: StringWriter za upis i StringReader za čitanje. U osnovi, u takav memorijski tok mogu se upisivati stringovi ili pojedinačni znakovi. Čitaju se pojedinačni znakovi ili ceo tok kao jedan string. Pored toga, u kombinaciji sa drugim čitačima-pisačima (BufferedWriter-Reader, PrintWriter), memorijski tokovi mogu se prinuditi da se ponašaju kao "prave" memorijske datoteke, tekstuelne ili znakovne.

10. Ulazno-izlazni podsistem

289

Klasa StringWriter izgrađena je oko objekta klase StringBuffer koji smo već razmotrili u poglavlju 8. Ima sledeći sadržaj86:

String void void void

StringWriter() toString() write(int ch) write(String str) write(char[] chBuff)

Konstruktor Izdavanje sadržaja u vidu jednog stringa. Upis jednog znaka. Upis stringa. Upis niza znakova.

Za čitanje služi klasa StringReader: StringReader(String str)

int int

read() read(char[] chBuff)

Konstruktor. Zapazimo da se čitač konstruiše iz stringa. Povezivanje sa pisačem ostvaruje se preko toString() pisača. Učitavanje jednog znaka. Učitavanje u znakovni bafer. Metoda vraća broj učitanih znakova ili -1 ako ih više nema.

U osnovi, objekti klasa StringWriter i StringReader ponašaju u odnosu na memorijske tokove se kao objekti klasa redom FileWriter i FileReader u odnosu na datoteke. Vezuju se na isti tok na poseban način. Pisač se vezuje za memorijski tok konstruktorom: StringWriter pisac = new StringWriter(); //upisivanje u memorijski tok . . . . . StringReader citac = new StringReader(pisac.toString()); //citanje memorijskog toka

Objekti klasa BufferedWriter, BufferedReader, PrintWriter itd. kombinuju sa objektima FileWriter odn. FileReader da bi se ostvarile razne vrste prenosa, sa konverzijom ili bez nje. Identičnim postupkom, ali na osnovu klasa StringWriter i StringReader, postižu se odgovarajući efekti sa memorijskim tokovima. Nekoliko takvih postupaka prikazano je u sledećem primeru: StringIO.java import java.io.*; import java.util.StringTokenizer; class StringIO { public static void main(String args[]) throws IOException { System.out.println("STRING KAO MEMORIJSKA DATOTEKA"); //KORISCENJE STRINGA KAO TEKSTUELNE MEMORIJSKE DATOTEKE //1.Prenos bez konverzije System.out.println("\nPRENOS BEZ KONVERZIJE"); StringWriter strOut1 = new StringWriter(); BufferedWriter out1= new BufferedWriter(strOut1); out1.write("This is a text line.\n"); out1.write("Another text line."); 86

Kao i dosad, dajemo pregled izabranih metoda klase.

10. Ulazno-izlazni podsistem

out1.close(); BufferedReader in1= new BufferedReader( new StringReader(strOut1.toString())); String s1; while((s1=in1.readLine())!=null) System.out.println(s1); in1.close(); //2.Upis sa konverzijom System.out.println("\nUPIS SA KONVERZIJOM"); StringWriter strOut2 = new StringWriter(); PrintWriter out2= new PrintWriter(strOut2); int primeNumbers[] = {2,3,5,7,9}; for(int i=0;i<5;i++) out2.println(primeNumbers[i]); BufferedReader in2= new BufferedReader( new StringReader(strOut2.toString())); System.out.println("First five prime numbers:"); String s2; while((s2=in2.readLine())!=null) System.out.println(s2); in2.close(); //3.Ulaz sa konverzijom System.out.println("\nCITANJE SA KONVERZIJOM"); String inputString = "1 2 3 4 5"; BufferedReader in3= new BufferedReader( new StringReader(inputString)); String s3= in3.readLine(); StringTokenizer strToken = new StringTokenizer(s3," "); int niz[] = new int[strToken.countTokens()]; int n=0,j,zbir; while(strToken.hasMoreTokens()) { niz[n++]= Integer.valueOf(strToken.nextToken()).intValue(); } System.out.print("Array niz= "); for(zbir=0,j=0;j
290

10. Ulazno-izlazni podsistem

291

while((i1=strIn1.read())!=-1) System.out.print((char)i1); in1.close(); } }

Izlaz iz ovog programa ima sledeći izgled: STRING KAO MEMORIJSKA DATOTEKA PRENOS BEZ KONVERZIJE This is a text line. Another text line. UPIS SA KONVERZIJOM First five prime numbers: 2 3 5 7 9 CITANJE SA KONVERZIJOM Array niz= 1 2 3 4 5 Sum is 15

STRING KAO ZNAKOVNA MEM. DATOTEKA This is a sequence of characters.Another sequence of characters.

10.5.2. Niz znakova kao memorijski tok Memorijski tok u vidu znakovnog niza realizuje se klasama CharArrayWriter i CharArrayReader. Klase imaju skoro isti repertoar metoda kao klase StringWriter i StringReader i koriste se na isti način. Razlika je u tome što se memorijski segment ugrađen u tok tretira kao niz znakova, a ne string. Povezuju se slično klasama iz prethodnog odeljka: CharArrayWriter pisac = new CharArrayWriter(); //upisivanje u memorijski tok . . . . . CharArrayReader citac= new CharArrayReader(pisac.toCharArray ()); //citanje memorijskog toka

Ostalo je isto, osim jedne mogućnosti: memorijski tok ovog tipa može se preneti u druge vrste tokova metodom void writeTo(Writer out) throws IOException

Sledećim segmentom će se niz znakova 'a' 'b' 'c' 'd' 'e' 'f' upisati na znakovni tok chOut, a zatim preneti u memorijski tok strOut tipa stringa. CharArrayWriter chOut = new CharArrayWriter(); char[] chArr = {'a','b','c','d','e','f'}; chOut.write(chArr); StringWriter strOut = new StringWriter(); chOut.writeTo(strOut);

10. Ulazno-izlazni podsistem

292

Ako se sada izvrši naredba System.out.println("\n\n"+strOut.toString());

na ekranu će se pojaviti tekst abcdef

10.6. POSTAVLJANJE OBJEKATA NA TOKOVE. SERIJALIZACIJA U dosadašnjim razmatranjima vezivali smo se za ulazno-izlazne operacije nad podacima koji su sami po sebi linearne sekvence bajtova: bazni tipovi, nizovi sa elementima baznih tipova i stringovi. S obzirom na svoju prirodu čistog objektnog jezika, java mora raspolagati i sredstvima za prenos objekata gde situacija nije ni izbliza tako jednostavna kao u prethodnim slučajevima (ako je i tamo bila jednostavna). Generalno, objekat nije linearna struktura jer se njegov memorijski prostor u logičkom smislu sastoji od podataka, ali i referenci na druge objekte koje takođe sadrže reference na objekte itd. Da bi se objekat sačuvao u celosti, moraju se memorisati sva njegova polja, baznih tipova, ali i objekti. S druge strane, tokovi svih vrsta su linearne strukture i uvek se mogu shvatiti kao sekvenca bajtova sa posebnom interpretacijom ili bez nje. Prema tome, osnovni zadatak mehanizma za prenos objekata na tok i sa toka jeste pretvaranje objekta kao celine u linearnu sekvencu bajtova, odnosno restauracija objekta iz takve sekvence. Postupak za pretvaranje objekta u sekvencu bajtova nosi naziv serijalizacija. U javi se sprovodi vrlo prosto. Da bi se objekat serijalizovao, koriste se gotova sredstva sadržana u posebnoj klasi sa nazivom ObjectOutputStream. Prilikom upisa objekta putem metode writeObject iz te klase, serijalizacija se obavlja automatski. Metoda ima zaglavlje void writeObject(Object ob)

Standardni postupak podrazumeva serijalizaciju svih polja koja nisu statička ili koja nisu posebno označena kao polja koja se ne serijalizuju. Klasa, inače, raspolaže metodama za upis ne samo objekata nego i baznih tipova, nizova i stringova. Da bi se metoda writeObject mogla primeniti na argument ob, klasa kojoj on pripada mora biti pripremljena za serijalizaciju, a da bi se to proverilo ona mora implementirati interfejs Serializable. Interfejs nema ni polja niti metoda zato što služi isključivo kao potvrda da se objekti mogu serijalizovati. Programer nema sa samim postupkom serijalizacije nikakvih problema, jer su sve standardne klase i bazni tipovi već pripremljeni za serijalizaciju. Posao programera je prosto da u okviru deklaracije svoje klase i klasa čiji se objekti sreću kao polja, unese kvalifikator implements Serializable

Neka je K klasa za čije objekte treba obezbediti serijalizaciju. Tada njena deklaracija ima oblik modifikatori class K implements Serializable { . . . . . }

Kako smo rekli, serijalizacija se vrši automatski, prilikom aktiviranja metode writeObject iz klase čiji je naziv ObjectOutputStream i koja pripada starijoj UI hijerarhiji. Klasa se vezuje za neki od tokova putem konstruktora ObjectOutputStream(OutputStream out)

što znači da se objekti mogu upisivati na sve tokove koji nasleđuju tok OutputStream (videti odeljak 10.2.1). Neka je, na primer, potrebno obezbediti upisivanje objekata pomenute klase

10. Ulazno-izlazni podsistem

293

K u datoteku Objekti.dat. Odgovarajući objekat klase ObjectOutputStream kreiraćemo segmentom ObjectOutputStream out= new ObjectOutputStream( new FileOutputStream("Objekti.dat");

Neka je obK objekat klase K. Objekat se upisuje u datoteku naredbom out.writeObject(obK);

pri čemu se serijalizacija izvodi automatski. Objekat out zatvara se metodom close(). Restauracija objekta (čitanje) sa toka obavlja se posredstvom ObjectInputStream. Klasa raspolaže konstruktorom

klase

ObjectInputStream(InputStream in)

kojim se instanca vezuje za konkretan tok što nasleđuje klasu InputStream. Prethodno upisani objekat restauriše se metodom Object readObject()

a sama klasa, kao i ObjectOutputStream, raspolaže još nizom metoda za čitanje baznih podataka, nizova i stringova. Restauracija objekta obK iz gornjeg primera, izvršila bi se segmentom ObjectInputStream in= new ObjectInputStream( new FileInputStream("Objekti.dat"); obK= (K)in.readObject(); in.close();

Primer 10.8. Preradićemo klasu PhoneBook iz primera 8.6 tako da bude omogućeno čuvanje telefonskog imenika u datoteci na disku (što svakako ima smisla). Da bi se omogućila serijalizacija, nova verzija klase, za početak, mora implementirati interfejs Serializable. Pošto polja String owner i HashMap entries već implementiraju ovaj interfejs, dovoljno je zaglavlje klase proširiti konstruktom implements tako da dobije oblik public class PhoneBook implements Serializable

Pored toga, dodaćemo metode za upis imenika u datoteku i za restauraciju sa diska. Metoda za upis nosi naziv save i izgleda ovako: public void save(String filename) throws IOException { ObjectOutputStream out= new ObjectOutputStream( new FileOutputStream(filename)); out.writeObject(this); out.close(); }

gde je parametar filename putanja do datoteke u koju će biti upisan imenik. Obratiti pažnju na naredbu out.writeObject(this);

kojom objekat upisuje u datoteku sopstveni memorijski prostor.

10. Ulazno-izlazni podsistem

294

Metoda za učitavanje imenika sa diska nosi naziv open. Pošto objekat tek treba da se restauriše metoda je statička, pri čemu je moguće i drugo rešenje: realizovati metodu kao konstruktor. public static PhoneBook open(String filename) throws IOException,ClassNotFoundException { ObjectInputStream in= new ObjectInputStream( new FileInputStream(filename)); PhoneBook temp = (PhoneBook)in.readObject(); in.close(); return temp; }

Metoda vraća kao rezultat referencu na restaurisani objekat. Inače, izuzeci koji se generišu u obe metode obavezni su, jer ih generišu redom metode writeObject i readObject. Programski tekst klase u celini ima sledeći izgled: PhoneBook.java, verzija 2 //Telefonski imenik realizovan kao hes tabela //Omogucen upis imenika u datoteku na disku import java.util.*; import java.io.*; public class PhoneBook implements Serializable { private String owner; private HashMap<String,ArrayList<String rel="nofollow">> entries; //Konstruktori //Podrazumevani konstruktor postoji zbog readExternal public PhoneBook() {} public PhoneBook(String owner) { this.owner= owner; entries= new HashMap<String,ArrayList<String>>(); } //Ocitavanje vlasnika imenika public String getOwner() { return owner; } //Prazan imenik? public boolean isEmpty() { return entries.isEmpty(); } //Broj stavki u imeniku public int size() { return entries.size(); } //Upis nove stavke //Ako je vec postojala stavka sa tim kljucem odustaje se public boolean addName(String name) { if(containsName(name)) return false; ArrayList<String> phones = new ArrayList<String>(); entries.put(name,phones); return true; } //Brisanje stavke public boolean removeName(String name) { return (entries.remove(name)!=null) ? true : false; } //Brisanje svih stavki

10. Ulazno-izlazni podsistem

public void clearAll() { entries.clear(); } //Da li postoji stavka? public boolean containsName(String name) { return entries.containsKey(name); } //Ocitavanje niza brojeva telefona na osnovu imena //Ako ime ne postoji vraca se null public ArrayList<String> getPhones(String name) { return entries.get(name); } //Dodavanje telefonskog broja (ako ne postoji) public boolean addPhone(String name,String phone) { if(!containsName(name)) addName(name); if(entries.get(name).contains(phone)) return false; entries.get(name).add(phone); return true; } //Brisanje telefonskog broja public boolean removePhone(String name,String phone) { return entries.get(name).remove(phone); } //Brisanje svih brojeva public void clearPhones(String name) { entries.get(name).clear(); } //Kolekcija brojeva za dato ime public Collection<String> names() { return entries.keySet(); } //Iterator public Iterator<String> iterator() { return entries.keySet().iterator(); } //Upis u imenika datoteku public void save(String filename) throws IOException { ObjectOutputStream out= new ObjectOutputStream( new FileOutputStream(filename)); out.writeObject(this); out.close(); } //Ucitavanje imenika iz datoteke public static PhoneBook open(String filename) throws IOException,ClassNotFoundException { ObjectInputStream in= new ObjectInputStream( new FileInputStream(filename)); PhoneBook temp = (PhoneBook)in.readObject(); in.close(); return temp; } }

Primer programa za formiranje imenika i njegovo upisivanje na disk: import java.util.*; public class Save {

295

10. Ulazno-izlazni podsistem

296

public static void main(String args[]) { PhoneBook imenik = new PhoneBook("Branislav Sekulic"); System.out.println("VLASNIK IMENIKA: "+imenik.getOwner()); //Upis stavki u imenik imenik.addPhone("Jovic Jova","1111"); imenik.addPhone("Jovic Jova","1112"); imenik.addPhone("Jovic Jova","1113"); imenik.addPhone("Ilic Ilija","2222"); imenik.addPhone("Ilic Ilija","2223"); imenik.addPhone("Peric Pera","3333"); imenik.addPhone("Mikic Mika","4444"); imenik.addPhone("Mikic Mika","4445"); //Upis u datoteku try { imenik.save("Imenik.dat"); } catch(Exception e) { e.printStackTrace(); } } }

Restaruracija imenika iz datoteke Imenik.dat vrši se kao u sledećem programu: public class Restore { public static void showEntry(String txt,PhoneBook book,String name) { System.out.println(txt); if(!book.containsName(name)) { System.out.println("Nema takve stavke"); return; } System.out.print("IME: "+name+" BROJEVI: "); for(String number:book.getPhones(name)) System.out.print(number+" "); System.out.println(); } public static void main(String args[]) { try { PhoneBook imenik = PhoneBook.open("Imenik.dat"); //Prikaz imenika System.out.println("VLASNIK IMENIKA: "+imenik.getOwner()); System.out.println("\n\nSADRZAJ IMENIKA:"); for(String name:imenik.names()) showEntry("",imenik,name); } catch(Exception e) { e.printStackTrace(); } } }

Program generiše izlaz oblika VLASNIK IMENIKA: Branislav Sekulic

10. Ulazno-izlazni podsistem

297

SADRZAJ IMENIKA: IME: Mikic Mika

BROJEVI: 4444 4445

IME: Ilic Ilija

BROJEVI: 2222 2223

IME: Peric Pera

BROJEVI: 3333

IME: Jovic Jova

BROJEVI: 1111 1112 1113

Serijalizacija i restauracija su, kako vidimo, visoko automatizovani postupci. Prilikom primene metode writeObject serijalizuju se sva nestatička polja. Pri restauraciji metodom readObject, konstruktor klase se ne poziva. Za slučaj da programer želi da utiče na tok serijalizacije, java poseduje ne prevelik repertoar sredstava. Jedno od njih jeste modifikator transient

koji se stavlja u definiciju polja. Sadržaj takvih polja se, pri serijalizaciji, ne memoriše. Ako bismo, iz nekih razloga, želeli da se ime vlasnika imenika ne upisuje u datoteku, klasa PhoneBook počinjala bi ovako: import java.util.*; import java.io.*; public class PhoneBook implements Serializable { private transient String owner; private Hashtable entries;

Sada serijalizacija metodom writeObject ne obuhvata upis polja owner. Poziv demonstracionog programa Restore generisaće u ovom slučaju izlaz

VLASNIK IMENIKA: null

! SADRZAJ IMENIKA: IME: Mikic Mika

BROJEVI: 4444 4445

IME: Ilic Ilija

BROJEVI: 2222 2223

IME: Peric Pera

BROJEVI: 3333

IME: Jovic Jova

BROJEVI: 1111 1112 1113

Pored ovog, java raspolaže još jednim sredstvom za upravljanje serijalizacijom koje pruža nešto veće mogućnosti. Radi se o interfejsu Externalizable koji nasleđuje interfejs Serializable. Interfejs ima metodu za upis void writeExternal(ObjectOutput out) throws IOException

gde je ObjectOutput interfejs koji implementira klasa ObjectOutputStream. Metoda sama po sebi ne upisuje ništa, nego se unutar nje moraju posebno upisivati sva polja koja treba serijalizovati. Ono što se postiže primenom writeExternal jeste mogućnost da se, uz

10. Ulazno-izlazni podsistem

298

neposredno upisivanje, izvrše i druge radnje ako je to neophodno. Druga metoda interfejsa koja se mora operacionalizovati, jeste metoda void readExternal(ObjectInput in) throws IOException,ClassNotFoundException

koja služi za učitavanje. I za nju važi da se neposredno učitavanje mora obezbediti posebnim naredbama, uz primenu metoda za učitavanje svakog polja ponaosob. Metoda readExternal ima još jednu karakteristiku: prilikom aktiviranja (pošto se aktivira preko objekta koji treba učitati), pre izvršavanja tela metode izvršava se podrazumevani konstruktor klase. Nijedna od dve metode ne poziva se eksplicitno. Naime, ako klasa implementira Externalizable, aktiviranje metoda writeObject odnosno ReadObject, automatski izaziva izvršavanje redom writeExternal i readExternal. Ako bismo želeli da klasu PhoneBook vežemo za Externalizable morali bismo dopisati metodu writeExternal u okviru koje se upisuju polja owner i entries, kao i metodu readExternal u kojoj bi se ta polja učitavala sa toka. Navešćemo i takav primer, ali uz napomenu da je u pitanju isključivo ilustracija primene Externalizable klasa, pošto u konkretnom slučaju nema potrebe za ovakvim rešenjem. Sledeća verzija PhoneBook ponaša se isto kao i ona iz primera 10.8. PhoneBook.java (demonstraciona verzija za Externalizable klase) //Telefonski imenik realizovan kao hes tabela //Omogucen upis imenika u datoteku na disku import java.util.*; import java.io.*; public class PhoneBook implements Serializable { private String owner; private HashMap<String,ArrayList<String>> entries; //Konstruktori //Podrazumevani konstruktor postoji zbog readExternal public PhoneBook() {} public PhoneBook(String owner) { this.owner= owner; entries= new HashMap<String,ArrayList<String>>(); } //Ocitavanje vlasnika imenika public String getOwner() { return owner; } //Prazan imenik? public boolean isEmpty() { return entries.isEmpty(); } //Broj stavki u imeniku public int size() { return entries.size(); } //Upis nove stavke //Ako je vec postojala stavka sa tim kljucem odustaje se public boolean addName(String name) { if(containsName(name)) return false; ArrayList<String> phones = new ArrayList<String>(); entries.put(name,phones); return true; } //Brisanje stavke public boolean removeName(String name) { return (entries.remove(name)!=null) ? true : false;

10. Ulazno-izlazni podsistem

} //Brisanje svih stavki public void clearAll() { entries.clear(); } //Da li postoji stavka? public boolean containsName(String name) { return entries.containsKey(name); } //Ocitavanje niza brojeva telefona na osnovu imena //Ako ime ne postoji vraca se null public ArrayList<String> getPhones(String name) { return entries.get(name); } //Dodavanje telefonskog broja (ako ne postoji) public boolean addPhone(String name,String phone) { if(!containsName(name)) addName(name); if(entries.get(name).contains(phone)) return false; entries.get(name).add(phone); return true; } //Brisanje telefonskog broja public boolean removePhone(String name,String phone) { return entries.get(name).remove(phone); } //Brisanje svih brojeva public void clearPhones(String name) { entries.get(name).clear(); } //Kolekcija brojeva za dato ime public Collection<String> names() { return entries.keySet(); } //Iterator public Iterator<String> iterator() { return entries.keySet().iterator(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(owner); out.writeObject(entries); } public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException { owner= (String)in.readObject(); entries= (HashMap<String,ArrayList<String>>)in.readObject(); } //Upis u imenika datoteku public void save(String filename) throws IOException { ObjectOutputStream out= new ObjectOutputStream( new FileOutputStream(filename)); out.writeObject(this); out.close(); } //Ucitavanje imenika iz datoteke public static PhoneBook open(String filename) throws IOException,ClassNotFoundException { ObjectInputStream in= new ObjectInputStream( new FileInputStream(filename));

299

10. Ulazno-izlazni podsistem

300

PhoneBook temp = (PhoneBook)in.readObject(); in.close(); return temp; } }

10.7. KOMPRESIJA I KORIŠĆENJE ARHIVA Kompresija ("zipovanje") podataka predstavlja još jednu od mogućnosti koje pruža javina UI hijerarhija. Izvodi se prilikom upisa podataka na bilo koji tok, što smo morali da podvučemo jer je prva asocijacija vezana za pojam "zip" kompresija pri upisu u datoteku. Klase koje učestvuju u kompresiji-dekompresiji nalaze se u paketu java.util.zip i pripadaju starijoj hijerarhiji. Shodno osnovnoj podeli subhijerarhija u UI podsistemu, ovde ih ima dve: jedna je vezana za upis sa kompresijom, a druga za učitavanje sa dekompresijom. Opisaćemo ih ne upuštajući se u pojedinosti, jer detalja ima mnogo, a osnovni postupak je dosta jednostavan. Osnovna klasa u izlaznoj (kompresionoj) subhijerarhiji jeste klasa DeflaterOutputStream sa dve konkretne izvedene klase, ZipOutputStream i GZIPOutputStream koje se međusobno razlikuju po algoritmu kompresije. Bez gubljenja na opštosti opisaćemo primenu klase ZipOutputStream. Kompresija se ostvaruje "obmotavanjem" konstruktora kompresorske klase oko konstruktora toka na koji se vrši upis sa kompresijom. Konstruktor ima oblik ZipOutputStream(OutputStream out)

Ako je, dakle, potrebno izvršiti upis sa kompresijom nekih podataka u, recimo, datoteku ZippedFile.zip, naredba kojom se upis priprema, u najkraćem, ima oblik ZipOutputStream archive= new ZipOutputStream( new FileOutputStream("ZippedFile.zip"));

formiranje toka

gde je archive objekat preko kojeg će se vršiti upis sa kompresijom. Inače, nema prepreka da upis bude baferisan putem BufferedOutputStream, što ćemo prikazati u primeru. S obzirom na to da se u isti komprimovani tok smešta različit sadržaj (npr. "zipujemo" više datoteka u istu arhivu), komprimovane arhive podeljene su na tzv. stavke (engl. "entry"). Kod arhive sa više komprimovanih datoteka, za svaku od njih mora se definisati posebna stavka sa sopstvenim imenom koje se, po pravilu, poklapa sa imenom komprimovane datoteke. Stavke se modeluju klasom ZipEntry od čijih metoda izdvajamo konstruktor ZipEntry(String name)

gde je name naziv stavke. Pomenimo i metodu za očitavanje tog naziva String getName()

Podaci koji se upisuju na komprimovani tok, unose se u stavku. Da bi upis počeo mora se prvo formirati stavka naredbom naziv_arhive.putNextEntry(new ZipEntry("naziv_stavke"));

Ako je, recimo, potrebno upisivati komprimovane podatke u arhivu sa nazivom archive formiranu gore, i to u stavku MyFile.dat, odgovarajuća naredba bila bi formiranje stavke

archive.putNextEntry(new ZipEntry("MyFile.dat"));

10. Ulazno-izlazni podsistem

301

Ovim je priprema za upis sa kompresijom završena. Neposredno unošenje sa kompresijom, vrši se nekom od metoda sa nazivom write: upis

void write(int b) throws IOException void write(byte[] b) throws IOException void write(byte[] b,int offs,int len) throws IOException

Prva upisuje jedan bajt. Druga upisuje kompletan niz bajtova b. Trećom se upisuje deo niza bajtova b, počev od indeksa offs u iznosu od len bajtova. Pored navedenih, klasa ZipOutputStream raspolaže još nekim metodama poput close(), finish() (pražnjenje bafera bez zatvaranja toka), setComment(String comment) za upis komentara i još nekih. Čitanje komprimovanih tokova obavlja se korišćenjem ulazne subhijerarhije čiji je koren klasa InflaterInputStream, a konkretne klase za dekompresiju ZipInputStream i GZIPInputStream. Dekompresija se obavlja redosledom sličnim kompresiji. Prvo se formira ulazni dekompresioni tok "obmotavanjem" nekog od ulaznih tokova. Konstruktor klase (posmatraćemo klasu ZipInputStream) ima oblik ZipInputStream(InputStream in)

Za gornji primer arhiviranja, naredba za formiranje deokompresionog toka jeste ZipInputStream archive= new ZipInputStream( new FileInputStream("ZippedFile.zip"));

Učitavanje sa dekompresijom vrši se na bazi stavki formiranih prilikom kompresije. Metoda kojom se dohvata sledeća stavka jeste ZipEntry getNextEntry() throws IOException

koja vraća referencu na ZipEntry i ima vrednost null kada više nema stavki za učitavanje. Za naš primer, dohvatanje sledeće stavke iz komprimovane datoteke ZippedFile.zip obavlja se porukom dohvatanje stavke

archive.getNextEntry()

Čitanje sa dekompresijom obavlja se metodama koje su dualne metodama za upis iz klase ZipOutputStream. To su metode čitanje

int read() throws IOException int read(byte[] b) throws IOException int read(byte[] b,int offs,int len) throws IOException

Prvom se učitava jedan bajt. Druga i treća učitavaju sekvencu bajtova u niz b[] i smeštaju je u prvom slučaju od početka, a u drugom od mesta offs u iznosu od len bajtova. Obe metode vraćaju kao rezultat broj učitanih bajtova. Osim navedenih, klasa ZipInputStream ima i metode close() za zatvaranje toka, closeEntry() za zatvaranje stavke, available() koja vraća 1 osim kada se stigne na kraj stavke i još neke. Primer 10.9. Kao ilustraciju, napravićemo dve izvršive klase (tj. programa) za kompresiju jedne ili više datoteka u zip arhivu, kao i za odgovarajuću dekompresiju. Za ovakav primer opredeljujemo se ne zato što ima veliku praktičnu važnost (takvi programi odavno postoje), nego zato što smatramo da je problematika bliska čitaocu. Podsetimo se, kompresija i dekompresija ne vezuju se obavezno za datoteke - primenljive su i na druge vrste tokova.

10. Ulazno-izlazni podsistem

302

Program za kompresiju realizovan je kao klasa ZipFiles. Zamišljen je tako da se pokreće uz primenu argumenata sa komandne linije. String args[0] sadrži naziv datoteke koja će biti arhiva, dok ostali stringovi redom sadrže nazive datoteka koje se komprimuju. Program se sastoji od dva dela. U prvom se kreira datoteka u koju će biti smeštena arhiva, a čiji naziv je određen parametrom args[0]. U drugom delu, za svaku od datoteka koje treba spakovati u arhivu (imena su args[1], args[2],...) formira se stavka u arhivi, porukom putNextEntry, pri čemu se naziv stavke poklapa sa imenom datoteke. Potom se formira tok nextFile za ulaz podataka iz datoteke. Konačno, vrši se upis sa kompresijom, sve dok ima podataka (bajtova) u ulaznoj datoteci. Ovaj postupak ponavlja se sve dok ima datoteka koje treba spakovati u arhivu. Za učitavanje podataka koristi se starija hijerarhija (tok, a ne čitač) samo zato što se starija hijerarhija koristi i za pakovanje. Inače, ne bi bila greška ni da smo koristili čitač. ZipFiles.java //Program za kompresiju (zipovanje) jedne ili vise datoteka //args[0] = ime zip datoteke //args[1]... = imena datoteka koje se zipuju import java.io.*; import java.util.zip.*; public class ZipFiles { public static void main(String args[]) { try { //Kreiranje datoteke za arhiviranje ZipOutputStream archive = new ZipOutputStream( new BufferedOutputStream( new FileOutputStream(args[0]))); int b; for(int i=1;i<args.length;i++) { //Kreiranje stavke za kompresiju archive.putNextEntry(new ZipEntry(args[i])); //Priprema datoteke za kompresiju BufferedInputStream nextFile= new BufferedInputStream( new FileInputStream(args[i])); //Upis sa kompresijom System.out.print("Compressing file: "+args[i]); while((b=nextFile.read())!=-1) archive.write(b); nextFile.close(); System.out.println(" ... [Done]"); } archive.close(); } catch(Exception e) { e.printStackTrace(); } } }

Drugim programom, UnzipFiles.java izvršava se suprotan zadatak: raspakivanje arhive u datoteke čija su imena takođe u arhivi, u okviru odgovarajućih stavki i čitaju se metodom getName() klase ZipEntry. Program prima jedan argument sa komandne linije i on predstavlja ime arhive. U prvom delu formira se tok ZipInputStream za ulaz komprimovanih podataka. Potom se u ciklusu koji je konstrolisan vraćenom vrednošću metode getNextEntry prvo učitava stavka, zatim formira izlazna datoteka i na kraju vrši čitanje iz arhive, dekompresija i upis u raspakovanu datoteku.

10. Ulazno-izlazni podsistem

303

UnzipFiles.java //Program za dekompresiju jedne ili vise zipovanih datoteka //args[0] = ime zip fajla import java.io.*; import java.util.zip.*; public class UnzipFiles { public static void main(String args[]) { try { //Otvaranje datoteke za arhiviranje ZipInputStream archive = new ZipInputStream( new BufferedInputStream( new FileInputStream(args[0]))); ZipEntry zipEntry; int b; //Iteriranje po stavkama arhive while((zipEntry=archive.getNextEntry())!=null) { //Priprema datoteke za prihvat dekomprimovanih podataka BufferedOutputStream nextFile= new BufferedOutputStream( new FileOutputStream(zipEntry.getName())); //Dekompresija stavke System.out.print("Decompressing file: "+ zipEntry.getName()); while((b=archive.read())!=-1) nextFile.write(b); nextFile.close(); System.out.println(" ... [Done]"); } archive.close(); } catch(Exception e) { e.printStackTrace(); } } }

Primer korišćenja programa ZipFiles za pakovanje datoteka File1.txt i File2.txt u arhivu Archive.zip: java ZipFiles Archive.zip File1.txt File2.txt

Izlaz izgleda ovako: Compressing file: Compressing file:

File1.txt ... [Done] File2.txt ... [Done]

Raspakivanje se vrši komandom java UnzipFiles Archive.zip

sa izlaznim tekstom Decompressing file: File1.txt ... [Done] Decompressing file: File2.txt

...

[Done]

11. OSNOVI KONKURENTNOG PROGRAMIRANJA Dajkstra (E.W. Dijkstra), jedan od najvećih znalaca u oblasti programiranja uopšte, svojevremeno je napisao da je program uputstvo za rad namenjeno računaru kao izvršiocu [Di68]. Ono što se stvarno dešava prilikom izvršavanja programa, tj. uputstva, on je nazvao procesom. Proces je, dakle, program u izvršavanju (prema [No97]87 ). Jedan od najvažnijih zadataka operativnog sistema je da realizuje višeprocesni rad, tj. da obezbedi mogućnost da se na računaru paralelno izvršava više procesa (tzv. multitasking). Ideja je jednostavna (sada već veoma stara). U osnovnoj varijanti zasniva se na razlici u brzini između procesora i UI uređaja zbog koje, u monoprogramskom ambijentu, procesor uglavnom stoji jer svoj deo posla obavlja daleko najbrže. Kada jedan proces zahteva ulaznoizlaznu operaciju, procesor je slobodan i može da prihvati obradu drugog procesa, trećeg itd. Na taj način ostvaruje se svojevrsna raspodela poslova na takav način da resursi računara u vidu procesora, memorije, periferija itd. budu iskorišćeni u što većoj meri. Dok jedan proces koristi jedan UI resurs, drugi proces koristi drugi resurs, treći koristi procesor itd. Pri tom se, naravno, mora voditi računa i o tome šta se dešava ako dva procesa istovremeno zahtevaju isti resurs. Postoje vrlo sofistikovani algoritmi kojima se rukuje takvim zahtevima. Jedan od klasičnih je, na primer, tzv. round robin algoritam za upravljanje procesorom gde se procesima koji čekaju na obradu kružno dodeljuje određeni kvantum vremena. Kada proces potroši dodeljeni kvantum, a nije završio sa korišćenjem procesora, stavlja se u red čekanja da bi ponovo dobio neki kvantum vremena itd. Konkurentno programiranje je način izrade programa koji koristi isti pristup, ali na nivou jednog programa. Drugim rečima, program se piše tako da prilikom izvršenja - dakle kao proces - generiše više potprocesa što se odvijaju u paraleli, uz moguće deljenje resursa, kako hardverskih tako i resursa samog programa (objekata). Osnovni pristup je isti kao kod multitaskinga, s tim što se paralelni rad odvija na nivou jednog procesa i što je za izradu takvog programa zadužen programer. Potproces definisan u okviru programa nosi naziv nit (engl. "thread"), otkuda potiče engleski naziv "multithreading". Zapazimo da naziv "konkurentno programiranje" nije odabran slučajno, jer se zaista radi o načinu programiranja koji se bitno razlikuje od običnog, sekvencijalnog programiranja. Kod sekvencijalnog programa uvek se zna sledeći korak koji se će izvršiti (ili bar alternativni ako se radi o selekciji). U konkurentnom programiranju situacija je daleko fluidnija: koraci (naredbe) su raspodeljeni po nitima i, generalno gledano, sledeći korak ne zavisi od prethodnog nego od prethodnog koraka i stanja skupa aktivnih niti. Ova razlika je dovoljno velika da uzrokuje potpunu promenu načina razmišljanja, te otud i posebno ime - konkurentno programiranje. U javi, svaki program sastoji se od niti. Programi koje smo do sada pisali sastojali su se od jedne niti i to niti sa metodom main. Dodavanjem drugih niti, sekvencijalni program pretvara se u konkurentni u pravom smislu reči. I dalje: svaka konkretna nit je - objekat. Niti 87

Ima i drukčijih definicija.

11. Osnovi konkurentnog programiranja

305

koje realizuje programer pripadaju klasama što preuzimaju funkcionalnost od posebne klase sa nazivom Thread

Funkcionalnost se preuzima na dva načina: direktnim nasleđivanjem (standardni postupak) odnosno implementiranjem specijalnog interfejsa Runnable kada se klasa sa niti već izvodi iz neke klase, pa ne može naslediti Thread. Za početak, oslonićemo se na standardni postupak. Klasa Thread raspolaže prilično obimnim repertoarom metoda. Među njima, najvažnija je metoda run() koju, prilikom definisanja sopstvenih niti, programer mora redefinisati, jer se u nju ugrađuje posao koji nit treba da obavi. Metoda se ne poziva direktno. Data nit thr startuje se, po pravilu, iz druge niti (npr. main) porukom thr.start();

u kojoj je skriveno aktiviranje metode run. Dakle, ako klasu sa niti želimo (i možemo) da oformimo izvođenjem iz klase Thread, postupak je sledeći: prvo, treba oformiti klasu kojoj će nit pripadati. Opšta struktura klase je modifikatori class ime_klase extends Thread { . . . . . public void run() { //ovde se kodira posao koji nit obavlja } }

Nit se instancira standardno: ime_klase ime_niti = new poziv_konstruktora(parametri);

Startuje se naredbom ime_niti.start();

Dajemo odmah jedan, nešto uopšteniji, primer. Oformićemo klasu niti sa nazivom Nit koja pet puta izvršava metodu doSomething(), uz prethodno štampanje propratnog teksta. Metoda doSomething simulira neki posao koji traje 0 do 500 milisekundi. To se obavlja aktiviranjem metode sleep iz klase Thread koja zaustavlja odvijanje niti u vremenu što se zadaje kao argument. Metoda ima signaturu (zaglavlje) static void sleep(long milisekunde) throws InterruptedException

Izuzetak klase InterruptedException generiše se ako je neka nit prekinula obradu tekuće niti (one koja se izvršava). Odgovarajuća naredba u metodi doSomething ima oblik sleep((long)(Math.random()*500));

gde je argument pseudoslučajan broj u opsegu 0 do 500. Svrha ovakve realizacije metode jeste da simulira, po vremenu, izvršavanje različitih poslova. Sama pak metoda run() odvija se tako što se 5 puta aktivira metoda doSomething() uz štampanje propratnog teksta. Evo teksta klase Nit: Nit.java (verzija 1) public class Nit extends Thread { public Nit(String name) {

11. Osnovi konkurentnog programiranja

306

setName(name); } public void doSomething() throws InterruptedException { sleep((long)(Math.random()*500)); } public void run() { for(int i=0;i<5;i++) { try { System.out.println("Nit: "+getName()+ " Prolaz: " +(i+1)); doSomething(); } catch(InterruptedException e) { e.printStackTrace(); } } } }

Uočimo u metodi run poziv metode getName(). Svakoj niti se dodeljuje ime tipa String, bilo automatski, bilo posebnom metodom iz klase Thread sa signaturom void setName(String name)

Ako se ime niti ne zada na ovaj način, biće dodeljeno automatski, kao "Thread-" gde je  redni broj instance računat po momentu instanciranja od 0 pa nadalje. Metoda run u osnovi se sastoji od ciklusa for u kojem se 5 puta poziva metoda doSomething koja svaki put traje različito. U trenutku kada se iz doSomething nit privremeno blokira metodom sleep, procesor se oslobađa i može da izvršava druge poslove, ako ih ima. Da bismo ilustrovali kako se ponaša jedan proces sa više niti oformićemo program u kojem će se kreirati i startovati tri niti, nit0, nit1 i nit2: public class NitTest { public static void main(String args[]) { Nit n0 = new Nit("NIT-0"); Nit n1 = new Nit("NIT-1"); Nit n2 = new Nit("NIT-2"); n0.start(); n1.start(); n2.start(); System.out.println("Nit MAIN zavrsena!"); } }

Na kraju niti kojoj pripada main, štampa se poruka "Nit MAIN zavrsena!". Posmatrajmo jedan od mogućih izlaza iz ovog programa88 : Nit MAIN zavrsena! Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-2 Prolaz: 88

1 1 1 2 3 2 2 3 3 4

"Jedan od mogućih" jer redosled aktiviranja niti zavisi od generatora pseudoslučajnih brojeva Math.random().

11. Osnovi konkurentnog programiranja

Nit: Nit: Nit: Nit: Nit:

NIT-1 NIT-2 NIT-1 NIT-0 NIT-0

Prolaz: Prolaz: Prolaz: Prolaz: Prolaz:

307

4 5 5 4 5

Prvo što zapažamo jeste to da se program ne završava onda kada obrada "glavne" niti sa metodom main stigne do kraja. Štaviše, u ovom slučaju, ta nit je prva koja se završava, tako da odmah zaključujemo da se konkurentni proces završava onda kada se završi njegova poslednja nit, ma koja to bila. Drugo što se primećuje - a što smo i želeli da ilustrujemo - jeste redosled izvršavanja niti koji je, u ovom programu, slučajan. Koja će nit biti uključena zavisi od trajanja metode doSomething koje je varijabilno, pa otud i sasvim proizvoljan redosled aktiviranja niti. Ponovno izvršavanje ovog programa generisaće sasvim drukčiji izlaz: Nit MAIN zavrsena! Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz:

1 1 1 2 2 2 3 3 4 3 5 4 4 5 5

Prikazali smo i drugi izlaz da podvučemo da su različiti izlazi prilično normalna situacija u konkurentnom programiranju. Niti se mogu kreirati na još jedan način, implementiranjem interfejsa Runnable. Radi se o interfejsu sa samo jednom metodom void run()

tako da obaveza implementiranja podrazumeva da klasa sigurno ima metodu run. Sama nit realizuje se kao objekat-član klase. Ovaj objekat kreira se jednim od dva posebna konstruktora klase Thread oblika Thread(Runnable ob) Thread(Runnable ob,String name)

kojem objekat nove klase šalje kao argument ob sopstvenu referencu this (zato klasa mora implementirati Runnable). Nit se obično startuje u okviru konstruktora nove klase. Primenom ovog postupka, naša klasa Nit dobija nov oblik Nit.java (verzija 2) public class Nit implements Runnable { private Thread t; public Nit(String name) { t= new Thread(this,name); t.start(); }

11. Osnovi konkurentnog programiranja

308

public void doSomething() throws InterruptedException { Thread.sleep((long)(Math.random()*500)); } public void run() { for(int i=0;i<5;i++) { try { System.out.println("Nit: "+t.getName()+ " Prolaz: " +(i+1)); doSomething(); } catch(InterruptedException e) { e.printStackTrace(); } } } }

U klasi u kojoj se pokreće ovako realizovana nit više nema poruke start: public class NitTest { public static void main(String args[]) { Nit n0 = new Nit("NIT-0"); Nit n1 = new Nit("NIT-1"); Nit n2 = new Nit("NIT-2"); System.out.println("Nit MAIN zavrsena!"); } }

Naravno, ništa nas ne sprečava da u klasi Nit realizujemo posebnu metodu start koja pokreće nit: Nit.java (verzija 3) public class Nit implements Runnable { private Thread t;

//moze se ostaviti i otvorenim (public)

public Nit(String name) { t= new Thread(this,name); } public void start() { t.start(); } public void doSomething() throws InterruptedException { Thread.sleep((long)(Math.random()*500)); } public void run() { for(int i=0;i<5;i++) { try { System.out.println("Nit: "+t.getName()+ " Prolaz: " +(i+1)); doSomething(); } catch(InterruptedException e) { e.printStackTrace(); } } } }

11. Osnovi konkurentnog programiranja

309

Klasa iz koje se pokreću niti sada ima isti oblik kao u verziji 1. Kao što je naznačeno, nit t može se otvoriti modifikatorom public i tada nije potrebno redefinisati metodu start, već se nit pokreće i uopšte joj se pristupa preko polja t. Kada nit zahteva usluge procesora (i drugih deljenih resursa), a procesor je zauzet, ona se stavlja u red čekanja. Kada se procesor ili drugi takav resurs oslobodi, iz reda čekanja bira se sledeća nit za obradu. Algoritam izbora nije trivijalan i zavisi od operativnog sistema. Na jednu stvar, međutim, programer ima uticaja. Svaka nit prilikom kreiranja dobija tzv. prioritet, u javi int broj kojim se utiče na redosled izbora. Nit sa većim prioritetom može se uzeti u obradu "preko reda". Prioritet niti postavlja se ili menja metodom final void setPriority(int priority)

a čita se po potrebi metodom final int getPriority()

Najveći, nominalni i najmanji prioritet nalaze se u klasi Thread kao imenovane konstante public static int MAX_PRIORITY public static int NORM_PRIORITY public static int MIN_PRIORITY

sa tipičnim vrednostima redom 10, 5 i 1. Podrazumevana vrednost prioriteta je NORM_PRIORITY koja se dodeljuje u slučaju da nije upotrebljena metoda setPriority. Uticaj promene prioriteta možemo opet ilustrovati na istom primeru. No, da bi se taj uticaj osetio, niti moraju zahtevati procentualno veći iznos procesorskog vremena od onog koji smo programirali u prethodnim verzijama. Zato ćemo modifikovati metodu doSomething tako da vreme blokiranja bude mnogo kraće: public void doSomething() throws InterruptedException { sleep((long)(Math.random()*1)); }

Ako sada niti n0 zadamo najveći prioritet, tako što ćemo liniju u kojoj se kreira u klasi NitTest modifikovati u Nit n0 = new Nit("NIT-0"); n0.setPriority(Thread.MAX_PRIORITY);

dobija se izlaz u kojem je očigledan uticaj povećanog prioriteta: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit MAIN zavrsena! Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz:

1 2 3 4 5 1 1 2 2 3 3 4 4 5 5

11. Osnovi konkurentnog programiranja

310

Kako vidimo, nit n0 se čak završava pre svih ostalih niti jer, zbog visokog prioriteta, dobija procesorske usluge pre drugih (uključujući i nit MAIN). Već smo pomenuli da se proces sa nitima završava kada se poslednja nit završi, ma koja nit bila u pitanju. Međutim, postoji posebna vrsta niti koje ne moraju da se završe, tj. koje se završetkom programa prekidaju. To su niti što igraju ulogu pozadinskog (background) potprocesa čija obrada nije u vezi sa zadatkom programa (poput procesa GC - garbage collector-a). Nose naziv daemon89-niti. Nit se proglašava za daemon-nit pomoću metode final void setDaemon(boolean on)

gde vrednost true argumenta on znači da će nit posle izvršenja metode postati daemon-nit. Metoda se mora aktivirati pre startovanja niti. Inače, podrazumevano stanje niti je da nije daemon. Provera da li je neka nit daemon-nit vrši se metodom boolean isDaemon()

Da bismo ilustrovali ponašanje daemon-niti dodaćemo u primeru koji smo upotrebljavali klasu Daemon.java import java.io.*; public class Daemon extends Thread { public Daemon() { setName("DAEMON-1"); setDaemon(true); //nit se proglasava za DAEMON } public void run() { try { System.out.println("Daemon "+getName()+" startovan."); sleep(5000); //blokiranje niti na 5 sekundi System.out.println("Daemon "+getName()+" zavrsen."); } catch(InterruptedException e) { e.printStackTrace(); } } }

Posle startovanja, nit izdaje poruku o tome, zatim se blokira na 5 sekundi (znatno duže nego što ostale niti traju) i najzad treba da prikaže poruku o završetku. Ako sistem pokrenemo programom oblika //Test program za daemon-niti public class DaemonTest { public static void main(String args[]) { Nit n0 = new Nit("NIT-0"); Nit n1 = new Nit("NIT-1"); Nit n2 = new Nit("NIT-2"); Daemon d = new Daemon(); d.start(); //startovanje daemon-niti n0.start(); n1.start(); n2.start(); System.out.println("Nit MAIN zavrsena!"); } 89

Čita se "demon". Naziv ćemo navoditi bez transkripcije.

11. Osnovi konkurentnog programiranja

311

}

na ekranu će se formirati izlaz oblika Nit MAIN zavrsena! Daemon DAEMON-1 startovan. Nit: NIT-0 Prolaz: 1 Nit: NIT-1 Prolaz: 1 Nit: NIT-2 Prolaz: 1 Nit: NIT-1 Prolaz: 2 Nit: NIT-1 Prolaz: 3 Nit: NIT-0 Prolaz: 2 Nit: NIT-0 Prolaz: 3 Nit: NIT-2 Prolaz: 2 Nit: NIT-1 Prolaz: 4 Nit: NIT-0 Prolaz: 4 Nit: NIT-1 Prolaz: 5 Nit: NIT-2 Prolaz: 3 Nit: NIT-2 Prolaz: 4 Nit: NIT-2 Prolaz: 5 Nit: NIT-0 Prolaz: 5

DAEMON-1 se ne završava. Prekida se!

Kako vidimo, nit "NIT-0" završava se kao poslednja među nitima koje nisu daemon-niti. Nit DAEMON-1 je počela da se odvija, ali završetkom NIT-0 njen rad se prekida zbog zaustavljanja virtuelne mašine.

11.1. INTERAKCIJA IZMEĐU NITI Ako izuzmemo startovanje iz niti sa metodom main, u dosadašnjim razmatranjima niti su bile praktično potpuno nezavisne jedna od druge, u smislu odvijanja. Posle startovanja, svaka od njih obavljala je svoj zadatak autonomno, bez ikakve interakcije bilo sa drugim nitima, bilo sa niti main. U praksi, pored takvog slučaja nailazimo na situacije kada izvršavanje niti nije nezavisno, kada niti razmenjuju poruke i - naročito - kada niti koriste zajedničke resurse. Jedna od najjednostavnijih interakcija između dve niti ostvaruje se metodom koja ima signaturu final void () throws InterruptedException

Nit a koja šalje poruku b.() zaustavlja se i čeka na završetak niti b kojoj je poruka poslata. Po prijemu podatka o završetku, nit a se nastavlja. Preinačimo program NitTest u oblik public class NitTest { public static void main(String args[]) { Nit n0 = new Nit("NIT-0"); Nit n1 = new Nit("NIT-1"); Nit n2 = new Nit("NIT-2"); n0.start(); n1.start(); n2.start(); try { n0.(); n1.(); n2.(); } catch(InterruptedException e) { e.printStackTrace(); } System.out.println("Nit MAIN zavrsena!"); }

11. Osnovi konkurentnog programiranja

312

}

Nit u kojoj se nalazi main (nazvana MAIN) ulaskom u osenčeni blok zaustavlja se i čeka na završavanje niti redom n0, n1 i n2. Tek kada se te niti završe, nit MAIN se nastavlja i generiše poruku "Nit MAIN zavrsena!". Time smo obezbedili da se ova nit obavezno završava poslednja. Svaki izlaz iz ovog programa završava se porukom "Nit MAIN zavrsena!": Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-2 Prolaz: Nit: NIT-1 Prolaz: Nit: NIT-0 Prolaz: Nit: NIT-2 Prolaz: Nit MAIN zavrsena!

1 1 1 2 2 3 2 3 3 4 4 4 5 5 5

Usput, da pomenemo i specičnu terminologiju vezanu za niti: za nit koja nije završena, u javinoj terminologiji upotrebljava se izraz "alive", dok je nit koja je završena "dead". Provera da li je neka nit još uvek "živa" vrši se porukom baziranom na metodi final boolean isAlive()

koja vraća true sve dok se nit ne završi. Postoje još dve metode kojima data nit može uticati na neku drugu: to su metode suspend i resume. Metoda suspend privremeno zaustavlja rad niti kojoj se upućuje poruka (nit se "suspenduje"). Metodom resume suspendovana nit se aktivira, tj. nastavlja sa radom. Metode navodimo samo da bismo podvukli da se više ne koriste (imaju status deprecated), jer lako dovode do havarijske blokade celog procesa.

11.2. DELJENI RESURSI. SINHRONIZACIJA Otvaranje mogućnosti da skup procesa egzistira istovremeno, neminovno vodi ka situaciji u kojoj dva ili više njih u istom vremenskom intervalu zahtevaju isti resurs računara. Pošto resurs u jednom trenutku može da koristi samo jedan proces, postavlja se pitanje šta raditi sa ostalima? Odgovor je jasan i logičan: ako proces zahteva usluge trenutno zauzetog resursa, on mora da čeka. Kada se resurs oslobodi tako što drugi proces koji ga zauzima završi sa radom ili iskoristi dodeljeni kvantum vremena, resurs se alocira nekom od procesa koji čekaju. Upravljanje radom resursa jeste osnovni zadatak operativnog sistema još od šezdesetih godina prošlog veka kada je uvedeno multiprocesiranje, tada pod imenom "multiprogramiranje". Kada je reč o konkurentnom programiranju u javi, situacija je identična: niti u okviru procesa mogu koristiti usluge istih resursa, a razlika je samo u tome što se radi o jednom procesu i što su resursi - objekti. U konkurentnom programiranju deljeni resursi nisu nikakav specifikum. Naprotiv, radi se o nečemu što je sasvim normalno za takve programe i što se mora očekivati. Primer 11.1. Posmatrajmo jedan primer. Neka klasa Klijent simulira programe koji ostvaruju neki izlaz na ekran, pri čemu su objekti ove klase - niti. Klijenti formiraju blokove od po 5

11. Osnovi konkurentnog programiranja

313

linija teksta (trajanje formiranja linije je pseudoslučajan broj) i prosleđuju ga istom objektu što modeluje ekran, tj. objektu System.out. Klijent.java (nesihnronizovan) public class Klijent extends Thread { public Klijent(String klijentID) { setName(klijentID); } //Priprema linije private void pripremiLiniju() { try { sleep((long)(Math.random()*100)); } catch(Exception e) { e.printStackTrace(); } } //Stampanje 5 linija public void run() { for(int i=0;i<5;i++) { pripremiLiniju(); System.out.println("Stampa klijent "+getName()+ " Linija "+(i+1)); } } }

U demonstracionom programu Test kreiraju se i startuju tri klijenta: public class Test { public static void Klijent k1 = new Klijent k2 = new Klijent k3 = new k1.start(); k2.start(); k3.start(); } }

main(String args[]) { Klijent("1"); Klijent("2"); Klijent("3");

S obzirom na nedeterminističke intervale između štampanja linija, izlaz je promenljiv, ali uvek pokazuje karakteristiku poput sledećeg: Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa Stampa

klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent klijent

2 1 3 2 2 2 2 1 3 3 1 1 3 1 3

Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija Linija

1 1 1 2 3 4 5 2 2 3 3 4 4 5 5

11. Osnovi konkurentnog programiranja

314

Lako uočavamo da su blokovi teksta koje generišu niti izmešani, što svakako nije bila intencija! Jasno je šta se dogodilo: dok jedan klijent priprema sledeću liniju za prikaz, ekran je slobodan i može ga iskoristiti drugi klijent ako ima spremnu liniju za štampu Sve to uzrokuje da su izlazi koje generišu tri klijenta izmešani. Ova pojava poznata je pod imenom "race condition" ("utrkivanje"), [MD74]. Do nje dolazi kada je "raspoređivanje dva procesa (u našem slučaju niti) tako kritično da različit redosled dodele dovodi do različitih rezultata", [MD74]. Stvarni izvor problema u našem primeru je nepostojanje vremenske usklađenosti izvršavanja niti, tj. nedostatak sinhronizacije. Da bi se odvijanje niti sinhronizovalo, u ovom slučaju bilo bi neophodno obezbediti da ekran ostane u posedu niti koja ga je zauzela sve dok se ne odštampaju svih pet linija. Za to vreme ostale niti moraju čekati. Primer 11.2. Na vremensku neusklađenost odvijanja niti nailazimo u još jednoj, tipičnoj situaciji. Radi se o razmeni poruka između niti. Neka je MessageBox klasa čiji objekti služe kao posrednici u razmeni poruka, tako što pošiljalac upisuje poruku u polje msg, a primalac očitava to polje. Jednostavnosti radi, poruke ćemo modelovati običnim stringom. U klasi postoje metode put(String msg) za upis poruke i get() za očitavanje poruke. MessageBox.java (nesinhronizovana verzija, ne radi!) public class MessageBox { private String msg; public void put(String msg) { this.msg= msg; } public String get() { String temp=msg; msg= null; return temp; } }

Prilikom očitavanja poruke metodom get u polje msg upisuje se vrednost null da se ista poruka ne bi čitala više puta. Pošiljaoca poruka modelovaćemo pomoću niti klase Sender. Prlikom kreiranja, objekat se vezuje za odgovarajući objekat klase MessageBox u koji se poruka upisuje. Pošiljalac šalje 10 poruka: "Poruka 0", "Poruka 1" ,..., "Poruka 9". Poruke se šalju u neregularnim vremenskim intervalima od 0 do 100 milisekundi. Kraj transmisije označava se slanjem stringa "\0". Sender.java public class Sender extends Thread { private MessageBox mbox; public Sender(MessageBox mbox) { this.mbox= mbox; } public void run() { for(int i=0;i<10;i++) { try {sleep((long)(Math.random()*100)); //Sacekati } catch(InterruptedException e){} mbox.put("Poruka "+i); //Poslati poruku } mbox.put("\0"); //Kraj transmisije } }

Klasa Receiver modeluje primaoce poruka i takođe je realizovana kao nit. Objekti klase vezuju se za MessageBox tako što klasa ima polje tog tipa, sa nazivom mbox. Osnovni algoritam rada svodi se na ciklus while u kojem se očitava sadržaj pripadajućeg objekta mbox.

11. Osnovi konkurentnog programiranja

315

Ako nema poruke za čitanje (sadržaj mbox je null) iteriranje se nastavlja. Ako sadržaj nije null znači da je nova poruka spremna i ona se očitava, te prikazuje na ekranu. Ako je sadržaj poruke "\0", prikazuje se tekst "END OF TRANSMISSION" i nit završava sa radom. Receiver.java public class Receiver extends Thread { private MessageBox mbox; public Receiver(MessageBox mbox) { this.mbox= mbox; } public void run() { String msg; while((msg=mbox.get())!="\0") { if(msg==null) continue; //Ima li poruka? System.out.println(msg); //Prikazati poruku } System.out.println("END OF TRANSMISSION"); } }

Program Test za proveru ponašanja celog sistema razmene poruka jednostavan je: prvo se kreira objekat mbx klase MessageBox, zatim se kreiraju pošiljalac s i primalac r i vezuju za mbx. Na kraju, startuju se s i r. class Test { public static void main(String args[]) { MessageBox mbx = new MessageBox(); Sender s = new Sender(mbx); Receiver r = new Receiver(mbx); r.start(); s.start(); } }

Izvršavanjem programa Test dobijaju se različiti izlazi, s obzirom na stohastičke vrednosti intervala u između poruka. Jedan od izlaza imao je ovakvu formu: Poruka Poruka Poruka Poruka Poruka Poruka Poruka Poruka END OF

0 nema poruke 1 2 3 4 5 6 7 8 TRANSMISSION

nema poruke 9

Ako ponavljamo eksperiment, dobijaćemo drukčije izlaze, ali gotovo uvek bez poruke 9. Može se čak desiti da se program blokira! Uzrok ovakvom ponašanju sistema je (opet) nesinhronizovanost rada pošiljaoca i primaoca poruke. Ovakav kakav jeste, sistem ne garantuje da će se slanje i prijem poruke događati naizmenično. Ako je vremenski interval između slanja dve poruke dovoljno mali, pošiljalac će upisati novu poruku preko stare, nepročitane poruke. Takođe, može se desiti da se procesor dodeli primaocu u toku formiranja poruke od strane pošiljaoca, sa nepredvidivim posledicama. Ponovo nailazimo na situaciju da "različit redosled dodele dovodi do različitih rezultata". Da bi sistem funkcionisao korektno, neophodno je obezbediti da pošiljalac pri slanju poruke sačeka da se prethodna poruka pročita.

11. Osnovi konkurentnog programiranja

*

*

316

*

Problemi prikazani u oba prethodna primera imaju zajedničku karakteristiku: nedostaje mehanizam kojim bi se nit primorala da čeka na neki događaj. U primeru 11.1 nema načina da se, dok traje opsluživanje jedne niti, sve ostale prinude da čekaju na događaj - oslobađanje ekrana. U primeru 11.2 nema mogućnosti da se pošiljalac primora da sačeka da primalac preuzme poslednju nepročitanu poruku. Sinhronizacija jeste upravo to: skup sredstava kojima se usklađuje odvijanje niti u vremenu. Sredstava ima više i koriste se u zavisnosti od toga kakvu vrstu sinhronizacije želimo: treba li nit da ekskluzivno zauzme resurs i spreči ostale niti da mu pristupe ili nit treba da se blokira u očekivanju nekog događaja. Prvi pristup ilustrovan je primerom 11.1 u kojem bi klijent trebalo da zauzme ekran sve dok ne završi sa prikazom svih 5 linija. Drugi pristup odgovara primeru 11.2 gde pošiljalac treba da čeka sve dok se ne pročita poslednja poruka; isto tako, primalac treba da sačeka pojavljivanje nove poruke koju treba pročitati i obraditi. Mehanizam sinhronizacije u javi zasnovan je na posebnom polju koje nosi naziv brava (engl. "lock") ili monitor i koje poseduje svaki objekat. Brava je mehanizam pomoću kojeg se definišu dva globalna stanja objekta: zaključan ili otključan. Ima je i klasa za slučaj da njome operišu statičke metode. Bravom operišu posebni blokovi i metode nazvani sinhronizovanim blokovima odn. metodama. Prilikom aktiviranja sinhronizovanih blokovametoda obavezno se konsultuje brava. Ako je objekat zaključan pozivajuća nit se blokira i čeka otključavanje. Sinhronizovanim blokovima rešava se problem iz primera 11.1, a sinhronizovanim metodama onaj iz primera 11.2. Metode i blokovi koje smo do sada razmatrali (nesinhronizovane metode u nesinhronizovanim blokovima) ne utiču na bravu niti je konsultuju. Inače, radi se o objektnoj implementaciji mehanizama koji su poznati još od šezdesetih godina prošlog veka pod imenima wait and signal i semaphore, a formulisani su kroz radove Dajkstre, Hoara, Hansena, Barbare Liskov i još nekih. 11.2.1. Sinhronizovani blokovi Sinhronizovani blokovi su blokovi među kojima u datom trenutku može biti aktivan samo jedan. Inače, sinhronizovani blok je javina implementacija mehanizma poznatog pod imenom kritična sekcija. Izvršavanje bloka kontrolisano je bravom nekog objekta, tako da nit može da ga izvrši samo kada je ta brava otključana. Neka je sharedOb referenca na objekat kojim hoćemo da kontrolišemo sinhronizovani blok90 . Opšti izgled bloka je synchronized(sharedOb) { //naredbe bloka }

gde je synchronized rezervisana reč kojom se blok definiše kao sinhronizovan. nit 1

nit 2

synchronized(sharedOb) { ..... } synchronized(sharedOb) { ..... }

brava

sharedOb

Slika 11.1.

Kada neka nit, izvršavajući metodu u kojoj se nalazi sinhronizovani blok dođe do njegovog početka, konsultuje se brava objekta sharedOb. Ako je zaključana, nit se automatski postavlja u stanje čekanja dok se brava ne otključa (i data nit stigne na red, ako nije jedina koja čeka). Kada nit uđe u blok, brava se zaključava, tako da druge niti ne mogu da uđu u svoj sinhronizovani blok. Pri izlasku niti iz bloka, brava se otključava. Uočimo i to da se 90

To može da bude referenca na bilo koji objekat, uključujući i this.

11. Osnovi konkurentnog programiranja

317

mehanizmom sinhronizovanih blokova posao oko sinhronizacije poverava klijentu, jer se sinhronizovani blok nalazi u kodu klijenta, a ne objekta, slika 11.1. Pokazaćemo sada primenu sinhronizovanog bloka na primeru 11.1 koji ćemo preinačiti tako da sprečimo neželjeno mešanje izlaznog teksta niti na ekranu. Ono što nudi sinhronizovani blok jeste da nit ekskluzivno zauzme objekat System.out (dakle, ekran) sve dok se ne prikaže svih 5 linija, a da tek zatim kontrolu nad objektom dobije sledeća nit. Postupak je jednostavan: u okviru metode run, segment kojim se linija šalje na ekran zatvara se u sinhronizovani blok kontrolisan bravom objekta System.out. Klijent.java (sinhronizovan) public class Klijent extends Thread { public Klijent(String klijentID) { setName(klijentID); } //Priprema linije private void pripremiLiniju() { try { sleep((long)(Math.random()*100)); } catch(Exception e) { e.printStackTrace(); } }

sinhronizovani blok

//Stampanje 5 linija public void run() { synchronized(System.out) { for(int i=0;i<5;i++) { pripremiLiniju(); System.out.println("Stampa klijent "+getName()+ " Linija "+(i+1)); } } } }

Sinhronizovani blokovi odlikuju se sledećim osobinama: 1. Sinhronizacija se poverava klijentu, jer se blok nalazi u njegovom kodu, a ne u kodu deljenog objekta. 2. Ulaskom u sinhronizovani blok, klijent ekskluzivno zauzima čitav objekat, što znači da nijedna metoda deljenog objekta nije na raspolaganju drugim klijentima. Sinhronizovani blok upotrebljava se u slučajevima kada klijent pristupa deljenom objektu više puta uzastopce, a pri tom između dva pristupa objekat ne sme promeniti stanje. Primer 11.1 jeste tipičan slučaj, jer se između štampanja dve uzastopne linije, ekran ne sme prepustiti drugom klijentu. Primenjuje se takođe kada se koriste gotove klase bez ugrađene sinhronizacije. 11.2.2. Sinhronizovane metode Sinhronizovanje metoda je nešto sofistikovaniji način za upravljanje deljenim resursima. Sinhronizovane metode su metode koje prilikom izvršavanja konsultuju bravu objekta preko kojeg su pozvane. Pri tom, vrlo je važno podvući da sinhronizovane metode pripadaju klasi deljenog objekta, što znači da su glavne karakteristike ovog postupka sledeće dve:

11. Osnovi konkurentnog programiranja

318

1. Sinhronizacija se ugrađuje u deljeni objekat (a ne u klijent kao kod sinhronizovanih blokova), poštujući jedno od temeljnih načela objektnog programiranja da "objekat treba da vodi brigu sam o sebi". 2. Sinhronizacija se sa nivoa celog objekta spušta na nivo metoda. Kada neka nit izvršava sinhronizovanu metodu, metoda je nedostupna za ostale niti koje je pozivaju preko istog deljenog objekta, a takođe i za sve druge sinhronizovane metode. Štaviše, u toku izvršavanja jedne sinhronizovane metode, nijedna sinhronizovana metoda ne može se pozvati preko istog deljenog objekta. Razlog za sve ovo je činjenica da se pri pokretanju sinhronizovane metode proverava brava. Ako je brava zaključana, nit koja je pozvala metodu blokira se čekajući da nit koja trenutno koristi metodu završi. Pri otpočinjanju izvršavanja sinhronizovane metode, objekat se zaključava. Metode se pretvaraju u sinhronizovane dodavanjem službene reči synchronized među modifikatore, tako da zaglavlje tipične sinhronizovane metode ima izgled pristup synchronized tip ime(parametri)

Vratimo se primeru 11.2 gde smo ustanovili da metode put i get u klasi MessageBox ne smeju da prekidaju jedna drugu kada se odnose na isti deljeni objekat npr. mbox. Da bi se to ostvarilo metode se moraju sinhronizovati tako da dobiju zaglavlja public synchronized void put(String msg) public synchronized String get()

Nažalost, ovo nije dovoljno. Naime, ostaju još problemi vezani za upis kada stari sadržaj još nije pročitan, odnosno čitanje kada nema poruke. Ono što se mora obezbediti jeste sledeće: 



Kada nit klase Sender pokrene metodu put, a objekat mbox već sadrži nepročitanu poruku, nit se mora zaustaviti i sačekati da se poruka pročita metodom get od strane druge niti (klase Receiver). Za vreme čekanja, objekat mbox mora se otključati, jer u suprotnom primalac poruke ne može pokrenuti metodu get koja je sinhronizovana. Isto tako, kada nit klase Receiver pokrene metodu get, a poruke trenutno nema, nit se mora blokirati, a objekat otključati.

U oba slučaja, kada metode počnu sa izvršavanjem, objekat se ponovo zaključava. Na kraju rada metoda, mbox treba ponovo otključati. Svi ovi zadaci obavljaju se pomoću tri metode: wait, notify i notifyAll, pri čemu metoda wait ima tri oblika. Sve tri metode pripadaju klasi Object, tako da postoje u svakoj klasi. Vrlo su specifične jer se ne odnose na objekat preko kojeg su pozvane, nego na nit iz koje su aktivirane. Metoda wait izaziva blokadu niti koja ju je pobudila. Osnovna varijanta je oblika public final void wait() throws InterruptedException

Nit u okviru koje je metoda wait pozvana blokira se i čeka da neka druga nit aktivira metode notify ili notifyAll koje otvaraju bravu deljenog objekta. Kada se to desi i kada data nit dođe na red za obradu, deljeni objekat se ponovo zaključava i obrada počinje. Druge dve varijante metode wait su public final void wait(long ms) throws InterruptedException public final void wait(long ms,int ns) throws InterruptedException

kod kojih se propisuje maksimalno vreme čekanja na notifikaciju u milisekundama ili milisekundama i nanosekundama. Po isteku vremena čekanja, ako u međuvremenu nije bila izvršena notifikacija, nit se reaktivira.

11. Osnovi konkurentnog programiranja

319

Kada sinhronizovana metoda dođe do kraja, treba da otvori bravu da bi sama metoda kao i druge sinhronizovane metode mogle da se aktiviraju. To se izvodi metodama notify i notifyAll. Metoda final void notify()

otvara bravu i "budi" sledeću nit koja čeka na otvaranje brave, a to je nit koja je hronološki prva blokirana. Metodom notifyAll "bude" se sve niti koje čekaju i kontrolu preuzima nit sa najvećim prioritetom. Konačno, da bi upravljanje bravom bilo bezbedno, po izdavanju komande notify odn. notifyAll brava se neće odmah otvoriti, nego tek kad se odgovarajuća sinhronizovana metoda završi. Na taj način, struktura tipične sinhronizovane metode ima sledeći oblik: pristup synchronized tip sinhrMetoda(parametri) { //brava je zakljucana brava se otključava if(!uslovZaNastavak) try {wait(); } catch(InterruptedException e) { //obrada izuzetka } //OBRADA brava je zaključana notify(); . . . . . brava se otključava }

Vratimo se primeru 11.2. Videli smo da problemi u funkcionisanju sistema Sender MessageBox - Receiver nastupaju zbog toga što se metodama put i get dozvoljava Paralelno izvršavanje, narušavajući tako integritet stringa msg. Da bi sistem mogao da funkcioniše moraju se zadovoljiti sledeći uslovi:    

metoda put ne sme početi ako je metoda get aktivna; metoda put sme početi samo ako je msg==null, tj. ako je prethodna poruka pročitana; metoda get ne sme početi ako je metoda put aktivna; metoda get sme početi samo ako je msg!=null, tj. ako postoji poruka koja nije pročitana. put

get

Slika 11.2.

Receiver

Sender

Sva četiri uslova biće zadovoljena ako se metode put i get sinhronizuju. Odmah uočavamo da se sinhronizacija, u ovom slučaju, izvodi modifikacijom deljenog objekta MessageBox, dok klijenti ostaju neizmenjeni (sa jednom nevažnom modifikacijom klase Receiver, koju ćemo navesti kasnije). Novi kod metode put postaje:

11. Osnovi konkurentnog programiranja

320

public synchronized void put(String msg) { if(this.msg!=null) try {wait(); } catch (InterruptedException e) { System.out.println("Put interrupted."); } this.msg= msg; notify(); }

Pre svega, metoda put ne može da otpočne ako je metoda get aktivna jer su sinhronizovane. Posle aktiviranja, put proverava se da li je poslednja poruka pročitana. Ako nije nit koja zahteva put blokira se čekajući taj događaj. Kada se poruka očita, string msg dobija vrednosti null (ovo treba da obezbedi get) te put može otpočeti sa radom. Brava se zaključava i nova poruka upisuje u msg. Kada je posao završen, metodom notify obaveštava se da je objekat slobodan. Metoda get funkcioniše na isti način, s tim što posle čitanja string msg postaje null što je indikacija da je poruka pročitana. public synchronized String get() { String temp; if(msg==null) try {wait(); } catch (InterruptedException e) { System.out.println("Get interrupted."); } temp= msg; msg= null; notify(); return temp; }

Pošto je klasa MessageBox važan primer za razumevanje načina funkcionisanja sinhronizovanih metoda daćemo integralnu verziju: MessageBox.java (ispravljena verzija) import java.io.*; public class MessageBox { private String msg; public synchronized void put(String msg) { if(this.msg!=null) try {wait(); } catch (InterruptedException e) { System.out.println("Put interrupted."); } this.msg= msg; notify(); } public synchronized String get() { String temp; if(msg==null) try {wait(); } catch (InterruptedException e) { System.out.println("Get interrupted."); } temp= msg; msg= null; notify(); return temp; } }

11. Osnovi konkurentnog programiranja

321

Pomenuli smo da u klasi Receiver treba izvršiti nevažnu (i čak neobaveznu) izmenu. Radi se o tome da su metode put i get sada sinhronizovane i nema potrebe da se u Receiver-u proverava da li poruka postoji. Novi kod klase Receiver dobija oblik public class Receiver extends Thread { private MessageBox mbox; public Receiver(MessageBox mbox) { this.mbox= mbox; } public void run() { String msg=null; while((msg=mbox.get())!="\0") System.out.println(msg); System.out.println("END OF TRANSMISSION"); } }

gde je naredba za proveru da li postoji nepročitana poruka if(msg==null) continue;

uklonjena kao nepotrebna. Ako sada aktiviramo program test dobijamo korektan izlaz: Poruka Poruka Poruka Poruka Poruka Poruka Poruka Poruka Poruka Poruka END OF

0 1 2 3 4 5 6 7 8 9 TRANSMISSION

Da bismo rezimirali ponašanje sinhronizovanih metoda u odnosu na niti iz kojih su pozvane, vratićemo se korak natrag i detaljnije razmotriti stanja u kojima se može naći neka nit. To su sledeća stanja:    

Stanje New: nit je kreirana, ali nije startovana. Stanje Runnable: nit je startovana. Stanje Dead: nit je završena. Stanje Blocked: nit je privremeno blokirana u očekivanju nekog događaja.

Od navedenih stanja, najinteresantnije je, svakako, stanje Blocked. Nit se blokira iz jednog od sledećih razloga: 1. Iz niti se aktivira metoda sleep(long ms) koju smo već koristili. I za ovu metodu važi ista specifičnost kao i za wait: blokira se nit iz koje je metoda sleep pozvana! Nit ostaje blokirana za iznos argumenta u milisekundama. Dakle, događaj koji nit čeka jeste isključivo istek naznačenog vremena. Za razliku od wait metoda sleep ne otvara bravu. Postoji i druga varijanta metode u kojoj se vreme može zadati u milisekundama i nanosekundama. 2. Nit poziva neku od metoda wait. Dejstvo smo upravo opisali. 3. Nit čeka na završetak UI operacije. Blokada i deblokada izvršava se automatski, bez posredstva programera. 4. Nit poziva sinhronizovanu metodu preko zaključanog objekta.

11. Osnovi konkurentnog programiranja

322

Napomenimo, na kraju, da je većina metoda koje se nalaze u kontejnerskim klasama, kao i metoda vezanih za noviji javin UI podsistem (pisači i čitači) sinhronizovana. Primer 11.3. U poglavlju 7, primer 7.4 detaljno smo razradili cirkularni red. Podsetimo se, u pitanju je sekvencijalno realizovan red sa ograničenim kapacitetom capacity po kojem elementi "kruže" da bi se izbegla lažna prepunjenost. Pokazaćemo kako se primenom sinhronizacije, u uslovima konkurentnog programiranja, red (nazvan buffer) može koristiti bez bojazni od prepunjenosti, bez obzira na projektovani kapacitet. Sve što je potrebno uraditi jeste sinhronizovanje metoda put i get. Ideja je jednostavna i jasna: nit može upisivati u bafer dok u njemu ima mesta. Kada se bafer napuni, nit čeka. Isto tako, nit koja preuzima elemente iz bafera u slučaju da je bafer prazan - čeka. Odmah napominjemo da je ovakva realizacija upotrebljiva samo ako se upis (put) i čitanje (get) nalaze u različitim nitima. U suprotnom, moglo bi da se desi da nit čeka samu sebe, što bi dovelo do havarijske blokade programa (o ovim pojavama biće reči u posebnom odeljku). Buffer.java public class Buffer { private Object[] elements; protected int getPosition; protected int putPosition; public Buffer(int capacity) { elements= new Object[capacity+1]; getPosition= putPosition= 0; } private boolean isFull() { return getPosition == (putPosition+1)%elements.length; } public synchronized boolean isEmpty() { return putPosition==getPosition; } public synchronized void put(Object value) { //provera da li ima mesta u baferu if(isFull()) try { wait(); } catch(InterruptedException e) { e.printStackTrace(); } //upis value u bafer elements[putPosition]= value; putPosition= (putPosition+1)%elements.length; notify(); } public synchronized Object get() { //provera da li ima elemenata za ocitavanje if(isEmpty()) try { wait(); } catch(InterruptedException e) { e.printStackTrace(); } //citanje bafera Object retVal= elements[getPosition]; getPosition= (getPosition+1)%elements.length; notify(); return retVal; }

11. Osnovi konkurentnog programiranja

323

public synchronized void clear() { putPosition= getPosition; } }

Uočimo da je metoda isFull zatvorena, prosto zato što niti koje koriste bafer ovo stanje ne proveravaju. Primer 11.4. Daćemo još jedan primer sinhronizovanih niti, s tim što će se ovde pojaviti i gotove sinhronizovane niti, a demonstriraćemo i primenu daemon-niti. Napravićemo posebnu vrstu kontejnerske klase tipa ArrayList koja ne vrši fizičko uklanjanje elemenata (sa pomeranjem ka početku) odmah, nego u regularnim vremenskim intervalima čija vrednost je parametar. Klasa nasleđuje klasu ArrayList i nosi naziv GCArray. Uklanjanje elemenata vrši se metodom delete(int index) i to tako što se na poziciju index, umesto fizičkog uklanjanja elementa, upisuje null. Uz objekat klase opciono se konstruiše čistač koji je daemon-nit. Kada je uključen, svakih interval milisekundi (interval je parametar) čistač se uključuje i eliminiše sve null elemente iz dinamičkog niza. Sve metode klase sinhronizovane su, uključujući i metode preuzete iz klase ArrayList koje su već sinhronizovane. GCArray.java import java.util.ArrayList; /** Kontejner tipa ArrayList sa demonom za ciscenje. Uklanjanje elemenata ne vrsi se metodom remove, nego se na njihovo mesto upisuje null. U regularnim vremenskim intervalima demon se ukljucuje i uklanja elemente koji su jednaki null metodom delete(). Demon je realizovan kao unutrasnja klasa sa imenom Cleaner. Moze se ukljuciti i iskljuciti. Cleaner se aktivirasvakih "interval" milisekundi. */ public class GCArray extends ArrayList { private Cleaner cleaner; private class Cleaner extends Thread { GCArray arr; int interval; Cleaner(GCArray arr, int interval) { this.arr= arr; this.interval= interval; setDaemon(true); } public void run(){ while(true) { try { sleep(interval); } catch(InterruptedException e) { e.printStackTrace(); } synchronized(arr) { arr.cleanUp(); } } } } /** * Konstruktor. Definise i pokrece daemon cistac koji se aktivira * u intervalima od "interval" milisekundi. * @param interval Interval u ms u kojem se ukljucuje daemon * @param cleanerOn true ako se cleaner ukljucuje inace false */ public GCArray(int interval,boolean cleanerOn) { if(cleanerOn) {

11. Osnovi konkurentnog programiranja

324

cleaner = new Cleaner(this, interval); cleaner.start(); } } /** * Metoda za uklanjanje null elemenata iz niza. * Moze se koristiti i kada cleaner nije ukljucen. */ public synchronized void cleanUp() { int nulls, i; for(nulls=0,i=0;i<size();i++) if(get(i) == null) nulls++; else set(i-nulls,get(i)); if(nulls != 0) removeRange(size()-nulls,size()); } /** * Metoda za upis null na mesto index (logicko brisanje) * @param index Indeks niza na koji se upisuje null * @throws RuntimeException Ako je indeks izvan opsega */ public synchronized void delete(int index) { if((index<0)||(index>=size())) throw new RuntimeException("Index out of range."); set(index,null); } }

11.2.3. Kratak pregled metoda klase Thread Klasa Thread ima priličan broj metoda. Metode (bar većina) specifične su po tome što povratno utiču na nit koja ih je aktivirala, poput metode wait. Među njima ima i zastarelih: stop u dve varijante, suspend i resume za zaustavljanje, trajno ili privremeno, odnosno za revitalizaciju. Proglašene su za "deprecated" jer nisu bezbedne u smislu da mogu da izazovu trajnu blokadu pograma , tzv. "deadlock" (videti dalje).

static Thread void String void int static boolean boolean void boolean void

Thread() Thread(String name) Thread(Runnable t) Thread(Runnable t, String name) currentThread() setName(String name) getName() setPriority(int pr) getPriority() holdsLock(Object ob) isAlive() setDameon(boolean on) isDaemon() ()

Podrazumevani konstruktor. Konstruisanje sa zadavanjem imena niti. Konstruisanje niti na bazi objekta t. Isto, sa zadavanjem imena niti. Vraća referencu na trenutno aktivnu (tekuću) nit. Zadavanje imena niti. Očitavanje naziva niti. Prioritet dobija vrednost pr. Očitavanje prioriteta niti. Vraća true ako tekuća nit zauzima objekat ob. Da li je nit živa? Ako nije znači da je završila sa radom. Ako on ima vrednost true nit se proglašava za daemon nit. U suprotnom postaje obična. Da li je nit daemon? Nit koja je poslala ovu poruku čeka da se nit

11. Osnovi konkurentnog programiranja

void void

(long ms) (long ms,int ns)

void void

run() start()

static void static void String

sleep(long ms) sleep(long ms,int ns) toString()

static void

yield()

325

kojoj je poruka poslata završi. Isto, ali se čeka najviše ms milisekundi. Isto, sa čekanjem u milisekundama i nanosekundama. Metoda koja sadrži algoritam odvijanja niti. Startovanje niti. Metoda run počinje da se izvršava. Nit se blokira na ms milisekundi. Isto, ali u milisekundama i nanosekundama. Pretvaranje u string. String sadrži osnovne podatke o niti, npr. ime i prioritet. Nit prepušta procesor drugim nitima, ali ostaje aktivna. Metoda je bezopasna i služi samo za ubrzavanje programa.

U klasi postoje i imenovane konstante MIN_PRIORITY, NORM_PRIORITY i MAX_PRIORITY sa vrednostima minimalnog, nominalnog i maksimalnog prioriteta (obično, 1, 5 i 10). Inače, klasa ima još metoda. Podaci o njima nalaze se u dokumentaciji uz klasu.

11.3. DIREKTNA RAZMENA PODATAKA IZMEĐU NITI U prethodnom poglavlju upoznali smo se sa klasama koje pripadaju javinom UI podsistemu. Pomenuli smo i klase PipedOutputStream, PipedInputStream odnosno PipedWriter i PipedReader. Tipična primena ovih parova klasa vezana je upravo za konkurentno programiranje, jer služe za razmenu podataka znakovnog tipa između niti. Podsetimo, prve dve klase pripadaju starijoj, a druge dve novijoj UI hijerarhiji. Dajemo kratak pregled klasa PipedWriter i PipedReader. Pre svega, pipe ("cev") je kanal za prenos (protok) podataka koji se uspostavlja između niti-predajnika i niti-prijemnika. Objektima klase PipedWriter podaci se ubacuju u taj kanal, a objekti klase PipedReader služe za njihovo preuzimanje. Da bi se prenos podataka mogao obaviti, objekat klase PipedReader vezuje se posebnim postupcima za objekat klase PipedWriter (ili obrnuto, svejedno je). Kada se objekti klase PipedWriter i PipedReader povežu, jedna nit preko pisača upisuje znakove ili nizove znakova, a druga ih preko čitača učitava. Pri tom, metode za upis-čitanje su usklađene tako da metoda za čitanje učitava kada god na upisnoj strani postoje znakovi. Klasa PipedWriter (i srodna, PipedOutputStream iz starije hijerarhije) ima sledeći repertoar metoda: PipedWriter() PipedWriter(PipedReader r) void void

close() connect(PipedReader r)

void void void void

flush() write(int ch) write(char[] cBuf) write(char[] cBuf, int ofs, int len) write(String str) write(String str, int ofs,

void void

Konstruktor. Konstruktor kojim se objekat povezuje sa odgovarajućim čitačem. Zatvaranje pisača. Metoda za povezivanje sa čitačem. Alternativa za povezivanje konstruktorom. Čišćenje bafera (flaš). Upis znaka. Upis znakovnog niza cBuf. Upis dela niza od indeksa offs u iznosu od len znakova. Upis stringa str. Upis dela stringa str od indeksa offs u iznosu od len

11. Osnovi konkurentnog programiranja

int len)

326

znakova.

Klasa PipedReader (PipedInputStream) ima sledeće metode: PipedReader() PipedReader(PipedWriter w) void void

close() connect(PipedWriter r)

int int

read() read(char[] cBuf)

int

read(char[] cBuf, int offs, int len) ready()

boolean

Konstruktor. Konstruktor kojim se objekat povezuje sa odgovarajućim pisačem. Zatvaranje čitača. Metoda za povezivanje sa pisačem. Alternativa za povezivanje drugonavedenim konstruktorom. Učitavanje sledećeg znaka. Učitavanje niza znakova. Vraćena vrednost jednaka je broju učitanih znakova ili -1 ako više nema znakova. Isto, ali za deo niza od pozicije offs u iznosu od len znakova. Vraća true, ako ima znakova za učitavanje. Inače false.

U nedostatku standardnog prevoda, ovaj mehanizam sastavljen od pisača i čitača nazvaćemo transkribovanim imenom - pajp. Za ilustraciju načina funkcionisanja pajpa iskoristićemo uopšten primer klase Sender koja upisuje na pajp pojedinačne znakove i nizove znakova, kao i klase Receiver koja ih čita. Nit Sender ima za komponentu objekat klase PipedWriter preko kojeg šalje podatke. U metodi run prvo se šalje grupa znakova 'A' do 'F' praćena znakom EOS (imenovana konstanta sa vrednošću 0). Svrha ovog znaka jeste da prijemna nit Receiver može da se podesi da prima znakove sve dok ne naiđe na EOS. Između dve uzastopne predaje pravi se pauza u vrednosti pseudoslučajnog broja sa vrednostima nula do jedne sekunde. Po predaji ovih znakova, Sender šalje i niz cniz od 6 znakova 'a' do 'f'. Uočimo primenu metode flush kojom obezbeđujemo da kompletan posao oko predaje bude završen pre sledeće operacije.

Sender

Receiver Slika 11.3. Kod klase Sender ima sledeći izgled: Sender.java import java.io.*; public class Sender extends Thread { public static final int EOS=0; private PipedWriter pipeOut; public Sender(PipedWriter pw) { pipeOut= pw;

11. Osnovi konkurentnog programiranja

327

} public void run() { try { // Slanje pojedinacnih znakova for(int c='A';c<='F';c++) { sleep((int)(1000*Math.random())); pipeOut.write(c); pipeOut.flush(); } pipeOut.write(EOS); // Slanje niza char[] cniz = {'a','b','c','d','e','f'}; pipeOut.write(cniz); pipeOut.flush(); pipeOut.close(); } catch(Exception e) {} } }

Nit Receiver prihvata poruke. Kao komponentu ima čitač iz klase PipedReader koji se vezuje za odgovarajući pisač Sender-a (kako - videćemo). U prvom delu objekti ove klase učitavaju sekvencu znakova proizvoljne dužine, pri čemu se kraj sekvence prepoznaje po znaku EOS koji je poslao Sender. U drugom delu učitava se niz znakova dužine najviše 10, a stvarna vrednost broja učitanih znakova dobija se kao izlaz iz odgovarajuće metode read. Receiver.java import java.io.*; public class Receiver extends Thread { private PipedReader pipeIn; public Receiver(PipedReader pr) { pipeIn= pr; } public void run() { try { // Ucitavanje pojedinacnih znakova System.out.println("UCITAVANJE POJEDINACNIH ZNAKOVA"); char c; while((c=(char)pipeIn.read())!=Sender.EOS) System.out.println("Receiver received: "+c); //Ucitavanje niza System.out.println("\nUCITAVANJE NIZA"); System.out.print("Receiver received: "); char[] chArray= new char[10]; int n; n= pipeIn.read(chArray); for(int i=0;i
Pisač i čitač povezuju se na dva načina: posredstvom konstruktora ili korišćenjem metode connect. Pri tom, moguće je povezati čitač sa pisačem ili obrnuto. Neka je pw objekat klase PipedWriter, a pr objekat klase PipedReader. Povezivanje preko konstruktora obavlja se ovako:

11. Osnovi konkurentnog programiranja

328

PipedWriter pw = new PipedWriter(); PipedReader pr = new PipedReader(pw);

Ako koristimo metodu connect povezivanje se vrši na sledeći način: PipedWriter pw = new PipedWriter(); PipedReader pr = new PipedReader(); pr.connect(pw);

Ni u jednom slučaju naredbe ne moraju biti u sekvenci. Program Test kojim pokrećemo niti što smo ih ranije opisali, ima za zadatak da poveže pisač i čitač, zatim da prosledi "krajeve" pajpa odgovarajućim nitima i najzad da pokrene niti Sender i Receiver: import java.io.*; public class Test { public static void main(String args[]) throws Throwable { PipedWriter pw = new PipedWriter(); PipedReader pr = new PipedReader(pw); Sender s = new Sender(pw); Receiver r = new Receiver(pr); s.start(); r.start(); } }

Program generliše sledeći izlaz: UCITAVANJE POJEDINACNIH ZNAKOVA Receiver received: A Receiver received: B Receiver received: C Receiver received: D Receiver received: E Receiver received: F UCITAVANJE NIZA Receiver received: a b c d e f

Primer 11.5. Ako pažljivije pregledamo repertoare klasa PipedWriter i PipedReader, primetićemo da u pisaču postoji metoda write za upis stringova, dok u čitaču odgovarajuće metode za čitanje nema. Kao još jedan primer vezan za pajpove, napravićemo klase StringPipedWriter i StringPipedReader u koje ćemo uključiti i takve metode: metodu writeString za upis stringa i metodu readString za čitanje. Klasa StringPipedWriter nasleđuje klasu PipedWriter i dodaje joj metodu za čitanje: StringPipedWriter.java import java.io.*; public class StringPipedWriter extends PipedWriter { static final int EOS=0; public StringPipedWriter() throws IOException { super(); } public StringPipedWriter(PipedReader pr) throws IOException { super(pr); } public synchronized void writeString(String str) throws IOException { write(str); write(EOS); flush();

11. Osnovi konkurentnog programiranja

329

} }

Konstruktori imaju istu ulogu kao konstruktori bazne klase, i eksplicitno ih pozivaju. Metodom writeString upisuje se string, s tim da se na kraju dodaje poseban simbol EOS da bi čitač mogao da ustanovi kraj stringa. Ovo zato što čitač ne može da čita ceo string (nema metode), nego čitanje vrši znak po znak, sve dok ne stigne do znaka EOS. Izlazni string iz metode readString akumulira se u objektu klase StringBuffer i pretvara u string u okviru naredbe return. StringPipedReader.java import java.io.*; public class StringPipedReader extends PipedReader { static final int EOS=0; public StringPipedReader() throws IOException { super(); } public StringPipedReader(PipedWriter pr) throws IOException { super(pr); } public synchronized String readString() throws IOException { StringBuffer strBuf = new StringBuffer(); char z; while((z=(char)read())!=EOS) strBuf.append(z); return strBuf.toString(); } }

Kao primer primene navedenih klasa, napravićemo opet uopštene klase Sender (predajnik) i Receiver (prijemnik) za razmenu poruka. Razmenu poruka u vidu stringova realizovaćemo tako da bude nešto komplikovanija nego u prethodnom primeru: predajnik će slati poruke prijemniku u neregularnim vremenskim intervalima, ali će i prijemnik vraćati odgovore, takođe u neregularnim intervalima. To znači da ovde moramo ostvariti obostranu vezu, putem dva pajpa: jedan za prenos poruka od predajnika ka prijemniku, a drugi za slanje odgovora, usmeren od prijemnika ka predajniku. Razmena podataka teče na sledeći način: 1. Predajnik formira poruku metodom prepareMessage (simulirano pomoću sleep), šalje je prijemniku i čeka odgovor. 2. Prijemnik prihvata poruku, obrađuje je metodom processMessage (takođe simulirano), vraća predajniku odgovor i prelazi u stanje čekanja na novu poruku. Ako je primio poruku "EOT", prijemnik završava sa radom. 3. Predajnik prihvata odgovor i procesira ga simulatorom processAnswer, a zatim prelazi na korak 1. Predajnik šalje ukupno 10 poruka i završava slanjem stringa "EOT". Programski tekstovi predajnika i prijemnika imaju sledeći oblik: Sender.java import java.io.*; public class Sender extends Thread { private StringPipedWriter pipeOut; private StringPipedReader pipeIn; public Sender(StringPipedWriter pw,StringPipedReader pr) { pipeOut= pw; pipeIn= pr; }

11. Osnovi konkurentnog programiranja

330

//Simulacija pripreme poruke private void prepareMessage() throws InterruptedException { sleep((long)(Math.random()*100)); } //Simulacija obrade odgovora private void processAnswer(String s) { System.out.println("PREDAJNIK primio odgovor: "+s); } public void run() { try { String s; for(int i=0;i<10;i++) { prepareMessage(); //priprema poruke pipeOut.writeString("P"+i); //slanje poruke s= pipeIn.readString(); //prijem odgovora processAnswer(s); } pipeOut.writeString("EOT"); pipeOut.close(); } catch(Exception e) {e.printStackTrace();} } }

Receiver.java import java.io.*; public class Receiver extends Thread { private StringPipedReader pipeIn; private StringPipedWriter pipeOut; public Receiver(StringPipedReader pr,StringPipedWriter pw) { pipeIn= pr; pipeOut= pw; } //Simulacija obrade poruke private void processMessage(String s) throws InterruptedException { System.out.println("PRIJEMNIK primio poruku: "+s); } public void run() { try { String s; while(true) { s=pipeIn.readString(); //prijem poruke if(s.equals("EOT")) break; processMessage(s); //obrada poruke pipeOut.writeString("Obradjena poruka "+s); //odgovor } System.out.println("END OF TRANSMISSION."); pipeIn.close(); } catch(Exception e) {e.printStackTrace();} } }

U programu treba napraviti dva pajpa za obostrani prenos i startovati niti Sender-a i Receivera.

11. Osnovi konkurentnog programiranja

331

import java.io.*; class Test { public static void main(String args[]) throws Throwable { StringPipedWriter pwSender= new StringPipedWriter(); StringPipedReader prReceiver= new StringPipedReader(pwSender); StringPipedWriter pwReceiver= new StringPipedWriter(); StringPipedReader prSender= new StringPipedReader(pwReceiver); Sender s = new Sender(pwSender,prSender); Receiver r = new Receiver(prReceiver,pwReceiver); s.start(); r.start(); } }

Jedan od mogućih izlaza iz programa bio bi PRIJEMNIK primio poruku: P0 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P1 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P2 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P3 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P4 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P5 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P6 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P7 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P8 PREDAJNIK primio odgovor: Obradjena PRIJEMNIK primio poruku: P9 PREDAJNIK primio odgovor: Obradjena END OF TRANSMISSION.

poruka P0 poruka P1 poruka P2 poruka P3 poruka P4 poruka P5 poruka P6 poruka P7 poruka P8 poruka P9

11.4. UKLEŠTENJE (DEADLOCK) Ukleštenje (engl."deadlock")91 je stanje procesa u kojem bar jedna nit čeka nemoguć događaj, izazivajući tako trajnu blokadu procesa. Do ove pojave može doći i na nivou operativnog sistema, kada čitav proces čeka događaj koji se ne može desiti. Pojava je nosila i naziv "smrtni zagraljaj" ("deadly embrace"), jer je najjednostavniji slučaj vezan za dve niti. Neka su data dva resursa, R1 i R2 i neka su N1 i N2 dve niti u okviru istog procesa. Do ukleštenja dolazi u situaciji kada nit N1 koja zauzima resurs R1 čeka na oslobađanje resursa R2, a istovremeno nit N2 što zauzima resurs R2 čeka na oslobađanje R1, slika 11.4.

91

"Ukleštenje" nije standardni izraz. Koriste se i izrazi "mrtva petlja" i "zastoj". Programeri upotrebljavaju nepreveden izraz "dedlok".

11. Osnovi konkurentnog programiranja

332

R1 N1

N2 R2 Slika 11.4.

Događaj koji ne može da se desi jeste "oslobađa se R1 ili R2". Ovakvu vrstu ukleštenja nije teško izazvati. Proces koji će doći u ukleštenje generiše se ovakvim programom: //Resurs public class Resurs { public void Stampaj(String poruka) { System.out.println(poruka); } } //Nit public class Nit extends Thread { Resurs res1,res2; public Nit(String nitID,Resurs res1,Resurs res2) { setName(nitID); this.res1= res1; this.res2= res2; } private void radiNesto(int msec) { try { sleep(msec); } catch(Exception e) { e.printStackTrace(); zauzimanje resursa res1 } } public void run() { synchronized(res1) { radiNesto(200); zauzimanje resursa res2 synchronized(res2) { radiNesto(50); res2.Stampaj("Stampa nit" +getName()); } res1.Stampaj("Stampa nit "+getName()); } } } //Program sa uklestenjem //Nit N1 drzi resurs R1 i trazi resurs R2 //Nit N2 drzi resurs R2 i trazi resurs R1 class DeadlockTest { public static void main(String args[]) throws Throwable { Resurs R1 = new Resurs(), R2 = new Resurs(); Nit N1 = new Nit("nit-1",R1,R2), N2 = new Nit("nit-2",R2,R1); DEADLOCK! N1.start(); N2.start(); N1.(); N2.(); System.out.println("Program zavrsen!");

11. Osnovi konkurentnog programiranja

333

} }

Prilikom startovanja, nit N1 prvo zauzima resurs R1, a zatim "radi nešto" u toku 200 milisekundi. Za to vreme startuje se nit N2 koja zauzima R2 i takođe "radi nešto" tokom 200 milisekundi. U međuvremenu nit N1 je završila sa metodom radiNesto i zahtevala zauzeti resurs R2, zbog čega je blokirana. Konačno, nit N2 takođe završava sa metodom radiNesto, zahteva zauzeti resurs R1 i takođe se blokira. Sada N1 čeka na N2 i N2 čeka na N1 što je školski primer ukleštenja. Ukleštenje je mnogo veći problem nego što, možda, izgleda na prvi pogled. Naime, upravo prikazani primer jeste najjednostavniji slučaj, a ukleštenje se javlja u vrlo različitim situacijama. Recimo, nit može da čeka na dejstvo druge niti koja je završena ("mrtva"). Dalje, nit N1 može da čeka nit N2, N2 da čeka N3 itd. i Nk-1 da čeka Nk i Nk da čeka N1 što je daleko teže detektovati od slučaja dve niti. Do ukleštenja može doći i kod sinhronizovanih metoda, kada, u sekvenci, jedna metoda čeka jedna na završetak sledeće, kao u poslednjem primeru niti N1, N2, itd. Zbog veoma divergentnih uslova koji dovode do ukleštenja, nažalost, stoji zaključak:  Ne postoji efikasan univerzalan postupak za prevenciju ukleštenja. Inače, postoji čitav niz pojedinačnih metoda u čije detalje se nećemo upuštati. Navešćemo samo jedan od najprostijih: da bi se sprečila pojava ukleštenja kritični segment započinje se zauzimanjem svih resursa koji se koriste u tom segmentu. Na taj način se sprečava da neka druga nit zauzme bilo koji od resursa i do ukleštenja ne može doći. Za naš primer, odgovarajući zahvat bio bi u kodu metode run klase Nit: public void run() { synchronized(res1) { synchronized(res2) { radiNesto(200); zauzimanje resursa res1 i res2 radiNesto(50); res2.Stampaj("Stampa nit" +getName()); } res1.Stampaj("Stampa nit "+getName()); } }

Ovakvo rešenje je potpuno pouzdano, ali u opštem slučaju obara performansu konkurentnog procesa. Naime, zauzimanjem više resursa od strane jedne niti, sve ostale niti primoravaju se da čekaju na sve te resurse, što je u suštini suprotno osnovnoj intenciji sinhronizacije - da se poveća iskorišćenje resursa.

12. ELEMENTI MREŽNOG PROGRAMIRANJA Pod mrežnim programiranjem podrazumevamo način izrade programa čiji procesi komuniciraju neposredno. U opštem slučaju, procesi mogu biti na istom računaru, ali takav slučaj je atipičan i služi uglavnom za testiranje. Tipičan slučaj je da su procesi na različitim računarima, tako da se razmena podataka vrši preko mreže, te otud naziv - mrežno programiranje. Mrežno programiranje u javi rešeno je na istim principima kao i sve ostalo: realizuje se objektno i poseduje visok nivo apstrakcije, tako da programer ne mora da poznaje detalje procesa prenosa podataka. Nosioci podataka koji se prenose su tokovi sa pripadajućim pisačima-čitačima, tako da se razmena podataka direktno naslanja na javin UI sistem. Dodatne funkcije, specifične za mreže, nalaze se u paketu java.net. Programe (ne računare!) koji ostvaruju međusobnu vezu nazivaćemo učesnicima. U načelu, učesnici ravnopravno razmenjuju podatke, no s obzirom na postupak uspostave veze i svrhu razmene podataka jedan učesnik igra ulogu klijenta, a drugi ulogu opslužioca ili servera. Model klijent-server jeste fundamentalni model za razmenu podataka u mreži, tako da ćemo izlaganje o osnovama mrežnog programiranja bazirati upravo na tom modelu. Jedan učesnik identifikuje se pomoću dva podatka: IP92 adresa i port93 preko kojeg učesnik ostvaruje vezu (koristi se i naziv konekcija). IP adresa može se zadati bilo kao kod 127.0.0.1

bilo putem imena, npr. java.sun.com

Programsko sredstvo kojim se uspostavlja veza između učesnika nosi naziv soket (priključak). Radi se o objektu koji pripada klasi Socket i snabdeven je metodama što omogućuju razmenu podataka sa drugim učesnikom. U procesu primopredaje podataka učestvuju po jedan soket koji pripada klijentu i jedan iz servera, slika 12.1.

92 93

IP je skraćenica od Internet Protocol. Softverska apstrakcija koja jednoznačno određuje tačku primopredaje podataka.

12. Elementi mrežnog programiranja

335

server

klijent

Socket

Slika 12.1.

ServerSocket

Da bi se mogla obaviti razmena podataka, svaki soket raspolaže po jednom komponentom iz klasa OutputStream i InputStream. U okviru servera postoji još jedan objekat klase ServerSocket koji ima za zadatak da, preko porta, primi od klijenta zahtev za uspostavu veze94 i da kreira odgovarajući soket. Naziv klase ServerSocket ne treba da zbuni: radi se o klasi koja nema mnogo veze sa klasom Socket i čiji objekti egzistiraju samo na strani servera. server

klijent

Slika 12.2. Osnovni model klijent-server demonstriraćemo na školskom primeru prenosa tekstuelne datoteke sa servera na klijent. Klijent šalje serveru naziv datoteke (može i putanju); server proverava da li na toj putanji postoji datoteka. Ako ne postoji, izveštava o tome klijenta porukom u vidu stringa. Ako datoteka postoji, server je čita liniju po liniju i šalje klijentu, slika 12.2. Primljene linije teksta klijent prikazuje na ekranu.

12.1. POSTUPAK NA STRANI KLIJENTA U načelu, klijent treba da obavi šest poslova. Kao prvo, treba da odredi adresu servera. U tu svrhu koristi se statička metoda getByName() što pripada klasi InetAddress. Argument  metode može biti IP adresa kao šifra, adresa kao ime ili vrednost null. Posebno, adresa lokalnog računara (onog na kojem se nalazi klijent) može se dobiti na čak četiri načina: preko metode getByName sa argumentima redom "localhost", null ili standardnim kodom "127.0.0.1" koji je uvek rezervisan za računar na kojem se dati program izvršava. Takođe, može se dobiti i primenom posebne metode getLocalHost(). Za pomenuti primer, klijent treba da odredi adresu servera. S obzirom na to da ćemo program testirati na jednom računaru, simuliraćemo adresu servera sa "127.0.0.1". Dakle, InetAddress addr = InetAddress.getByName("127.0.0.1");

Drugi korak je kreiranje soketa. Soket, kao što smo rekli, predstavlja objekat klase Socket koja je, inače, prilično bogata metodama. Konstruktor (ima ih više) koji se standardno koristi jeste sic! Socket(InetAddress adresa_servera, int port_servera)

94

Kaže se da "sluša port".

12. Elementi mrežnog programiranja

336

Šifra porta je proizvoljan pozitivan broj, pri čemu su vrednosti do 1024 zauzete, tako da ih treba izbegavati. Vrlo je važno uočiti da se kao argumenti zadaju adresa i port servera. Pod pretpostavkom da se server nalazi na adresi koju smo odredili pod imenom addr i da server "sluša" na portu 9000, soket klijenta kreiramo naredbom Socket clientSock = new Socket(addr,9000);

Napominjemo da klasa Socket raspolaže i konstruktorom koji, umesto objekta addr klase InetAddress, prima direktno string sa adresom. Konstruktori generišu izuzetke klase UnknownHostException u slučaju da ne može da se odredi IP adresa. Svaki soket snabdeven je jednim izlaznim tokom klase OutputStream i jednim ulaznim tokom klase InputStream, koji služe za primopredaju podataka. Da bi se ta primopredaja obavila neophodno je kreirati odgovarajući pisač i čitač, i to predstavlja sledeća dva koraka. Treći korak je kreiranje pisača na osnovu izlaznog toka soketa koji se dobija metodom klase Socket sa signaturom OutputStream getOutputStream() throws IOException

U zavisnosti od toga kakvi su podaci koji se predaju odnosno primaju, a na osnovu ovih tokova, kreiraju se odgovarajući pisač i čitač. Vratimo se našem primeru. Klijent treba serveru da pošalje naziv datoteke čiji sadržaj treba da dobije od servera. Radi se o stringu, te se zato odlučujemo za objekat klase PrintWriter: PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( clientSock.getOutputStream())),true);

gde, podsetimo, true znači da se string odmah upisuje na tok. Ulazni tok soketa (četvrti korak) dobija se metodom InputStream getInputStream() throws IOException

takođe iz klase Socket. Za naš primer, odgovor servera su linije teksta, pa čitač kreiramo kao objekat klase BufferedReader: BufferedReader in = new BufferedReader( new InputStreamReader( clientSock.getInputStream()));

Peti korak je centralno mesto, jer predstavlja komunikaciju zbog koje je i uspostavljena veza sa serverom. Obavlja se u zavisnosti od konkretnog zadatka, a svodi se na slanje poruka serveru preko pisača, odnosno prijem odgovora preko čitača. U datom slučaju, klijent šalje naziv datoteke čiji sadržaj server treba da prosledi. Naredba kojom se to obavlja je out.println("Text.txt");

gde je Text.txt naziv datoteke. Prijem odgovora, u vidu sekvence linija obavlja se segmentom String response; while((response=in.readLine())!=null) System.out.println(response);

12. Elementi mrežnog programiranja

337

gde se primljene linije odmah i štampaju. Poslednji, šesti, korak je prekidanje veze što podrazumeva zatvaranje pisača, čitača i soketa: in.close(); out.close(); clientSock.close();

Zbog važnosti primera, navodimo integralni tekst klase Client. Client.java import java.io.*; import java.net.*; public class Client extends Thread { public static void main(String args[]) { try { // (1) Odredjivanje adrese racunara sa kojim se povezuje InetAddress addr = InetAddress.getByName("127.0.0.1"); // (2)Otvaranje soketa prema drugom racunaru Socket clientSock = new Socket(addr,9000); // (3) Inicijalizacija pisaca PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( clientSock.getOutputStream())),true); // (4) Inicijalizacija citaca BufferedReader in = new BufferedReader( new InputStreamReader( clientSock.getInputStream())); // (5) K o m u n i k a c i j a // (5.1) Slanje zahteva System.out.println("\n[Klijent poslao]: Text.txt"); out.println("Text.txt"); // (5.2) Prijem odgovora String response; System.out.println("[Klijent primio]:"); while((response=in.readLine())!=null) System.out.println(response); // (6) Zatvaranje konekcije in.close(); out.close(); clientSock.close(); } catch(UnknownHostException e) { e.printStackTrace(); } catch(IOException e) {e.printStackTrace();} } }

Podvucimo još jednom: adresa servera 127.0.0.1 je adresa računara na kojem se nalazi i klijent, a koja je upotrebljena samo da bi se program mogao demonstrirati na jednom

12. Elementi mrežnog programiranja

338

računaru. U realnim uslovima, na mestu ove adrese nalazila bi se stvarna adresa servera dobijena ili direktno ili preko imena.

12.2. POSTUPAK NA STRANI SERVERA Slično klijentu, i ovde se postupak primopredaje podataka odvija u koracima ili fazama. Kao prvo, kreira se objekat klase sa nazivom ServerSocket koji, kao što smo rekli, nema mnogo veze sa soketom (i soket će se pojaviti). Ovde se radi o svojevrsnom senzoru za - kako se to kaže - "slušanje" porta. Zadatak mu je da obezbedi specijalnu metodu accept koja zaustavlja izvršenje servera u očekivanju da se na serverskom portu pojavi zahtev za opsluživanje. Kada se takav zahtev pojavi, metoda kreira i vraća kao rezultat "pravi" serverski soket preko kojeg će se odvijati razmena podataka sa serverske strane. Senzor za osluškivanje porta kreira se naredbom ServerSocket(int port)

gde je port oznaka porta servera koja mora da se poklopi sa oznakom porta pri definisanju klijentskog soketa. Za naš primer, odgovarajuća naredba bila bi ServerSocket listener = new ServerSocket(9000);

gde je 9000 oznaka porta servera (videti klijent). Sledeći, drugi, korak jeste aktiviranje metode accept naredbom Socket serverSock = listener.accept();

Izvršavanje servera se na ovom mestu zaustavlja - proces čeka da se na serverskom portu pojavi zahtev. Kada se to desi, metoda kreira soket i vraća ga kao rezultat koji se, u okviru iste naredbe, dodeljuje soketu serverSocket. Na taj način oformljen je i serverski soket koji komunicira sa klijentom istim mehanizmom kao i kod klijenta. Treba, dakle, inicijalizovati pisač (korak tri) kao i čitač (korak četiri). Uzimajući opet u obzir način na koji se, u konkretnom slučaju, razmenjuju podaci između servera i klijenta, pisač i čitač dobijaju redom sledeće oblike: PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( serverSock.getOutputStream())),true); BufferedReader in = new BufferedReader( new InputStreamReader( serverSock.getInputStream()));

Sledi korak pet: prelazak u fazu komunikacije sa klijentom. Server čita poruku koja (u primeru) sadrži naziv datoteke čiji sadržaj treba da pošalje klijentu. Naredba za čitanje je String fileName = in.readLine();

Ako datoteka ne postoji u direktorijumu servera, šalje se poruka File ime does not exist.

Ako datoteka postoji, njen sadržaj se prosleđuje klijentu. Segment programa kojim se obavlja ovaj posao mogao bi da izgleda ovako:

12. Elementi mrežnog programiranja

339

File f = new File(fileName); if(!f.exists()) out.println("File "+fileName+ " does not exist."); else { BufferedReader inFile = new BufferedReader( new FileReader(f)); String line; while((line=inFile.readLine())!=null) out.println(line); }

Poslednji, šesti korak je zatvaranje konekcije: in.close(); out.close(); serverSock.close(); listener.close();

Na kraju, kao i u slučaju klijenta, dajemo integralnu verziju servera. Vežbe radi, ubacili smo i naredbe System.out.print("\n[Server primio]: "+fileName); System.out.println(" [sa adrese]: "+ serverSock.getInetAddress());

kojima se štampa naziv datoteke kao i adresa sa koje je poslat zahtev (u test primeru to je 127.0.0.1). Server.java import java.io.*; import java.net.*; public class Server { public static void main(String args[]) { try { // (1) Definisanje soketa na kojem server slusa ServerSocket listener = new ServerSocket(9000); // (2) Slusanje porta Socket serverSock = listener.accept(); // (3) Inicijalizacija pisaca PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( serverSock.getOutputStream())),true); // (4) Inicijalizacija citaca BufferedReader in = new BufferedReader( new InputStreamReader( serverSock.getInputStream())); // (5) K o m u n i k a c i j a // (5.1) Citanje zahteva String fileName = in.readLine(); System.out.print("\n[Server primio]: "+fileName); System.out.println(" [sa adrese] : "+

12. Elementi mrežnog programiranja

340

serverSock.getInetAddress()); citanje adrese klijenta // (5.2) Odgovor na zahtev File f = new File(fileName); if(!f.exists()) out.println("File "+fileName+ " does not exist."); else { BufferedReader inFile = new BufferedReader( new FileReader(f)); String line; while((line=inFile.readLine())!=null) out.println(line); }

// (6) Zatvaranje konekcije in.close(); out.close(); serverSock.close(); listener.close(); } catch(IOException e) {e.printStackTrace();} } }

Kompletan sistem napravljen je tako da se može demonstrirati na jednom računaru. Sve što treba jeste 1. 2. 3. 4.

otvoriti dva DOS prozora u prvom pokrenuti server u drugom pokrenuti klijent po završetku zatvoriti oba.

12.3. SERVER SA VIŠE KLIJENATA Primer koji smo upotrebljavali, mada realan, ipak je suviše jednostavan. Realniji i upotrebljiviji model jeste server koji opslužuje više klijenata sa različitih adresa, slika 12.3. Način na koji se postiže opsluživanje više klijenata u isto vreme podrazumeva kombinaciju mrežnog i konkurentnog programiranja. Ideja se sastoji u tome da se, u serveru, blok obrade zahteva koji smo označili brojem 5 ("komunikacija") izmesti u nit. Po prijemu zahteva metodom accept, server formira nit za obradu i prosleđuje joj serverski soket generisan ovom metodom. Nit obavlja tri posla: kreira pisač i čitač u okviru soketa koji je prosleđen kao argument, te obavlja primopredaju podataka. Kreiranje pisača i čitača može se obaviti u okviru konstruktora niti, dok se neposredna komunikacija ugrađuje u metodu run. Nit se startuje iz konstruktora.

12. Elementi mrežnog programiranja

341

server

Slika 12.3. Primer 12.1. Postupak formiranja servera sa više niti za obradu demonstriraćemo na sledećem zadatku: klijent šalje serveru putanju nekog direktorijuma u vidu stringa. Posle provere da li takav direktorijum postoji, server šalje njegov sadržaj kao sekvencu objekata klase File. Po prijemu svakog objekta, klijent prikazuje na ekranu ime odgovarajuće datoteke odn. subdirektorijuma. U klijentu nema koncepcijskih novina, tj. realizuje se kao i u prethodnom primeru. Isto kao i ranije, server smo smestili na adresu 127.0.0.1 da bi se sistem mogao testirati na jednom računaru. Direktorijum čiji se sadržaj zahteva od servera jeste koreni direktorijum c sistema na kojem je instaliran server. Klijent.java import java.io.*; import java.net.*; public class Client { private static final int SERVER_PORT = 9999; public static void main(String args[]) { try { // Odredjivanje adrese servera InetAddress addr = InetAddress.getByName("127.0.0.1"); // Otvaranje soketa prema serveru Socket clientSock = new Socket(addr,SERVER_PORT); // Inicijalizacija pisaca PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( clientSock.getOutputStream())),true); // Inicijalizacija citaca ObjectInputStream in= new ObjectInputStream(clientSock.getInputStream()); // K o m u n i k a c i j a // Slanje putanje direktorijuma String dirPath = "c:/"; System.out.println("\nTrazi se sadrzaj direktorijuma: "+ dirPath+"\n\n"); out.println(dirPath);

12. Elementi mrežnog programiranja

342

// Listanje direktorijuma System.out.println("SADRZAJ SERVERSKOG DIREKTORIJUMA "+ dirPath); File inF; while((inF=(File)in.readObject())!=null) System.out.println(inF.getName()); // Zatvaranje konekcije in.close(); out.close(); clientSock.close();

Segment A (biće promenjen)

} catch(Exception e) { e.printStackTrace(); } } }

Server je realizovan bitno drukčije nego u prvom primeru, a razlika je u segmentu u kojem se obrađuju zahtevi klijenata. Po aktiviranju, a posle pripremnih radnji, server se zaustavlja na pozivu metode accept i čeka da se na portu pojavi zahtev za obradu. Po prijemu zahteva kreira se, kao i ranije, soket sa nazivom serverSock. Međutim, dalju obradu preuzima nit unutrašnje klase ServerThread koja za argument ima upravo kreirani soket. U sklopu konstruktora niti kreiraju se pisač i čitač i startuje se metoda run u koju su ugrađene naredbe za neposrednu razmenu podataka sa klijentom. Izlaz ka klijentu predstavlja sekvenca objekata klase File koji odgovaraju datotekama i subdirektorijumima. Sekvenca se završava sa null. Po obavljenoj komunikaciji, nit se završava. Ovakvim načinom postignuto je da server može da opsluži više klijenata istovremeno, jer se svaki od njih obrađuje u posebnoj niti. Server.java import java.io.*; import java.net.*; public class Server { private static final int PORT = 9999; //Port na kojem server slusa public static void main(String args[]) { try { // Definisanje soketa na kojem server slusa ServerSocket listener = new ServerSocket(PORT); while(true) { // Slusanje porta Socket serverSock = listener.accept(); // Iniciranje obrade zahteva klijenta new ServerThread(serverSock); } } catch(IOException e) { e.printStackTrace(); } } } //Nit za obradu zahteva klijenta class ServerThread extends Thread { private Socket sock;

12. Elementi mrežnog programiranja

343

private BufferedReader in; private ObjectOutputStream out; ServerThread(Socket sock) { this.sock= sock; try { // Inicijalizacija pisaca out= new ObjectOutputStream(sock.getOutputStream()); // Inicijalizacija citaca in = new BufferedReader( new InputStreamReader( sock.getInputStream())); } catch(Exception e) { e.printStackTrace(); } start(); } public void run() { try { // Citanje zahteva String request = in.readLine(); System.out.println("\nStigao zahtev od klijenta: "+sock); System.out.println("\nZahteva se sadrzaj direktorijuma: "+ request); // Odgovor na zahtev File dir = new File(request); if(dir.exists() & dir.isDirectory()) { File[] fileList = dir.listFiles(); for(int i=0;i
Segment B (biće promenjen)

} catch(IOException e) { e.printStackTrace(); } } }

Odmah da naglasimo, ovo rešenje prenosa podataka je potencijalno nebezbedno. "Potencijalno nebezbedno" znači da u konkretnom slučaju - štampanju naziva datoteka i direktorijuma - problema nema, ali sam mehanizam prenosa može biti pogrešno upotrebljen. Izvor nesporazuma jeste činjenica da klijent prima sadržaj direktorijuma koji se, u principu, nalazi na drugom računaru. Zbog toga, svaki pokušaj da se odgovarajući objekat klase File upotrebi za pristup datoteci ili direktorijumu na strani klijenta mora biti sprečen. Ovo je regulisano načinom serijalizacije pri prenosu, gde se prenosi samo apstraktna putanja, tako da

12. Elementi mrežnog programiranja

344

primena, recimo, metode exists na klijentskoj strani uvek treba da generiše rezultat false. Međutim, nije tako. Ako, recimo, neka datoteka na serveru postoji i na računaru klijenta, na istoj apstraktnoj putanji, klijent će moći da kreira tok i da pristupi takvoj datoteci, ali ne serverskom originalu, nego sopstvenoj, pogrešnoj verziji. Najgore od svega jeste činjenica da za takve "duplikate", kako datoteka tako i subdirektorijuma, važe sve metode klase File! Želimo li da izbegnemo ovu opasnost, treba obezbediti da se klijentu, umesto objekata klase File, prenesu samo stringovi sa apstraktnim putanjama sadržaja serverskog direktorijuma. Klijent i dalje može da kreira tokove vezane za sopstvene datoteke sa istim nazivima, ali je to toliko očigledno da će biti urađeno samo sa eksplicitnom namerom. Pored toga, metode klase File nisu primenljive na stringove te je rizik od nesporazuma praktično zanemarljiv. Za konkretan primer, najjednostavniji način modifikacije softvera jeste da se, umesto objekata klase File, klijentu prenesu stringovi kao objekti. Da bi se to postiglo treba promeniti zasenčene segmente označene sa A u klijentu i B u serveru. Segment A treba zameniti sa String inStr; while((inStr=(String)in.readObject())!=null) System.out.println(inStr);

Novi segment A

a segment B sa for(int i=0;i
Novi segment B

LITERATURA

Am96 Ar79 Bo94 Ca85 Co86 Da72 Di68 Di76 Dm79 Ec97 El00 FR84 HM00 Ho89 ISO1 Ja94 Jo95 Le70 Li83 Ls93 Ma01

Ma05 Ma94 Ma95

Amadi M., Cardelli L.: A Theory of Objects, Springer-Verlag, New York, 1996 Kalman R., Falb P., Arbib M.: Topics in Mathematical System Theory, McGrawHill, 1969 (prevod na ruski Mir, Moskva, 1979) Booch G.: Object-Oriented Analysis and Design, second edition, Addison-Wesley, 1994 Cardelli L., Wegner P.: On Understanding Types, Data Abstraction and Polymorphism, ACM Computer Surveys, 1985 Cox B.: Object Oriented Programming: An Evolutionary Approach, Reading MA, Addison - Wesley, 1986 Dahl O.-J., Dijkstra E.W., C.A.R. Hoare: Structured Programming, Academic Press, 1972 Dijkstra E.W.: Goto Statement Considered Harmful, Communications Of the ACM, vol. 11, 1968 Dijkstra E.W.: A Discipline of Programming, Prentice-Hall, 1976 De Marco T.: Structured Analysis and System Specification, Prentice-Hall, 1979 Eckel B.: Thinking in Java, Mind View Inc., 1997 Ellmer E.: Object-Orientation - an Overview, University of Viena, www.ifs.univie.ac.at/ISOO/overview.html Filozofijski rečnik, red. V. Filipović, Nakladni zavod Matice hrvatske, Zagreb, 1984. Hotomski P., Malbaški D.: Matematička logika i principi programiranja, Univerzitet u Novom Sadu, 2000. Van Horebeek I., Lewi J.: Algebraic Specifications in Software Engineering, Springer-Verlag, 1989 ISO/IEC 2382 - 17.02.5 Jacobson I.: Object-Oriented Software Engineering, Addison-Wesley, 1994 Jorgensen P.C.: Software Testing - A Craftman's Approach, CRC Press, 1995 Lerner A.J.: Principi kibernetike, Tehnička knjiga, Beograd, 1970. Lipaev V.V.: Kačestvo programmnogo obespečenija, Finansy i statistika, Moskva, 1983 Liskov B., Wing J.M.: A New Definition of the Subtype Relation, http://www.cs.cmu.edu/~wing/publications/CMU-CS-93-149.pdf, 1993 Malbaški D., Obradović D.: Objektna tehnologija: suština, stanje i perspektive, uvodni referat, IV Međunarodno savetovanje o dostignućima elektro i mašinske industrije, Banja Luka, 2001. Malbaški D.: Objekti i objektno programiranje, Univerzitet u Novom Sadu, Fakultet tehničkih nauka, 2006 Malbaski D., Obradovic D.: On Some Basic Concepts in Object Orientation, 6th Balcan Conference on Operational Research, Thessaloniki, 2002 Malbaški D., Obradović D.: Osnovne strukture podataka, Univerzitet u Novom

346

Sadu, 1995. Malbaški D.: Objektno orijentisano programiranje kroz programski jezik C++, Univerzitet u Novom Sadu, 2008. Ma15 Malbaški D.: Algoritmi i strukture podataka, Univerzitet Educons, 2015. MD74 Madnick S., Donovan J.: Operating Szstems, McGraw-Hill, 1974 Me03 Meyer B.: Objektno orijentisano konstruisanje softvera, prevod II izdanja, CET, Beograd, 2003. Me88 Meyer B.: Object-Oriented Software Construction, Prentice Hall, 1988 Mm94 Marković M.: Filozofski osnovi nauke, Izabrana dela, Tom I, BIGZ, Genes_S štampa, Prosveta, SKZ, 1994. Mr94 Marciniak J., ed.: Encyclopaedia of Software Engineering, John Wiley and Sons, 1994 Mt95 Martin R.: Deg Object-Oriented C++ Applications Using the Booch Method, Prentice Hall, 1995 No97 Noughton P., Schildt H.: Java: The Complete Reference, Osborne McGraw-Hill, 1997 OC95 The Oxford Companion to Philosophy, Oxford University Press, 1995 OE79 Opća enciklopedija Jugoslavenskog leksikografskog zavoda, Zagreb 1979. Parnas D.: On the Criteria to be Used in Decomposing Systems into Modules, Pa72 Comm. of the ACM, Dec. 1972 Parnas D., Clements P., Weiss D.: The Modular Structure of Complex Systems, Pa85 IEEE Trans. on Software Engineering, Vol. SE-11, March 1985 [Pe81] Petrović G.: Logika, Školska knjiga, Zagreb, 1981. Prešić S.: Elementi matematičke logike, Matematička biblioteka, Beograd, 1968. Pr68 Shaw M.: Comparing Architectural Design Styles, IEEE Software, November 1995 Sh95 Sm88 Smith M., Tockey S.: An Integrated Approach to Software Requirements Definition Using Objects, Scattle WA: Boeing Commercial Airplane Division, 1988 Snoeck M., Dedene G.: Existence Dependency: The Key to Semantic Integrity Sn98 Between Structural and Behavioral Aspects of Object Types, IEEE Trans. on Software Engineering, vol. 24, no. 4, April 1998 Stanford Encyclopedia of Philosophy, http://plato.stanford.edu SEP Strachey C.: Fundamental Concepts in Programming Languages, Lecture Notes Sr67 for International Summer School in Computer Programming, Copenhagen, 1967 Stroustrup B.: Programski jezik C++, Mikro knjiga, Beograd, 1991. St91 Stanojević I., Surla D.: UML - Uvod u objedinjeni jezik modeliranja, Grupa za St99 informacione tehnologije, Novi Sad, 1999. Wi76 Wirth N.: Algorithms+DataStructures=Programs, Prentice-Hall, 1976 Wi94 Wirth N.: A Plea for Lean Software, Computer, February 1995 Zamulin A.V.: Tipy dannyh v jazykah programmirovanija i bazah dannyh, Nauka, Za87 Sibirskoe otdelenije, 1987 Ma08

Related Documents 171j1w

Malbaski Programski Jezik Java 1h6b3d

November 2019 205

Sql Programski Jezik 2003 546u5l

November 2019 30

Laslo Kraus - Programski Jezik C 173b5k

September 2020 0

Grcki-jezik 6v702h

November 2019 40

Crkvenoslovenski Jezik 3q3b6r

December 2019 72

Starogrcki Jezik 6wj5w

March 2023 0

---

More Documents from "Alen Bajrovic" 2i6n4s

Malbaski Programski Jezik Java 1h6b3d

November 2019 205

5- 80616371-hp-5-harry-potter-and-the-order-of-the-phoenix.pdf h5h5v

December 2019 55

3-harry-potter-and-the-prisoner-of-azkaban-book.pdf 1j7361

October 2019 63

World Cheese Book o6t3r

November 2019 213

Organizational Feasibility Study 1n5w18

November 2019 142

6ta Clase Division Haptophyta 4c4w6k

December 2022 0

Copyright © 2025 IDOUB.