Embed Size (px)
DESCRIPTION
Seminarski rad
Citation preview
PANEVROPSKI UNIVERZITET APEIRONBANJA LUKA
Vanredne studijeSmjer „ Nastavnička informatika“
Predmet: Principi programiranja
Tema:“Objektno orjetisano programiranje“
Predmetni nastavnikProf. Dr Zoran Ž. Avramović dipl. ing.elektrotehnike
StudentArif Nuhanović
Index.br. 134-09/VNI
Banja Luka, Maj 2010. god.
1
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
SadržajUvod..........................................................................................................................................2OSNOVNE PREDNOSTI OOP......................................................................................................3Definicija razreda (klase)...........................................................................................................4
Dodavanje svojstava klasi TDate........................................................................................5Dodavanje događaja klasi TDate.......................................................................................8Metodi klase i podaci klase...............................................................................................9
Objekti.....................................................................................................................................10Ključna riječ Self..................................................................................................................10Privatni, zaštićeni i javni članovi..........................................................................................11Konstruktori.......................................................................................................................13Objekti i memorija.............................................................................................................13
Dinamičko kreiranje komponenata...................................................................................14Polimorfizam...........................................................................................................................15Nasljeđivanje...........................................................................................................................17PREGLED OBJEKTNO ORJENTISANI PROGRAMSKIH JEZIKA.....................................................20C++.......................................................................................................................................... 20
Povijest razvoja....................................................................................................................20Java (programski jezik)............................................................................................................20C sharp.................................................................................................................................... 20Python.....................................................................................................................................21Visual Basic..............................................................................................................................21
Nedostaci.............................................................................................................................21Pascal (programski jezik).........................................................................................................21
Povijest razvoja....................................................................................................................22Usporedba Object Pascala i ostalih objektno orijetiranih jezika..........................................22
Zaključak................................................................................................................................. 24Literatura:............................................................................................................................... 25
Arif Nuhanović; e-mail:[email protected]
2
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
UvodObjektno orijentirano programiranje ili kraće OOP je jedan od mogućih pristupa programiranju računara. Za razliku od ostalih pristupa, u kojima je težište na akcijama koje se vrše na podatkovnim strukturama, ovdje je težište na projektiranju aplikacije kao skupa objekata koji izmjenjuju poruke.Objektno orijentisano programiranje (Object Oriented Programming, OOP) je novi pristup realizaciji softvera kao modijela realnog sveta. U objektnim programskim sistemima sve je predstavljeno kao objekat (procesi, tekst, U/I- operacije itd.). Objektno programiranje zapravo najsličnije pisanju simulacija za realne objekte. Koncept procedura i podataka (koji se koristi u tradicionalnim višim programskim jezicima) zamenjen je konceptom objekata i poruka . Objekt predstavlja pakovanje informacija i opis za njihovu manipulaciju (skup operacija i procedura koje se nad datim podacima mogu izvršiti), a poruka je specifikacija jedne od manipulacija objektom.Za razliku od podataka koji su nepromenljivi (ili vrlo malo promenljivi), objekti su vremenski promenljivi i imaju stanja koja odgovaraju realnom svetu. Za razliku od procedura koje opisuju kako se izvodi određeni postupak obrade, poruka sadrži opis šta pošiljalac želi da se uradi, a primalac određuje šta će se tačno dogoditi, odnosno on obavi posao ili prenese poruku drugim objektima.Objekat ima svoje unutrašnje stanje čija je realizacija nedostupna drugim objektima i operacije (metode) koje se nad njim spolja mogu izvršavati.Klasa i objekat su dva termina koja se obično koriste u Object Pascalu i drugim OOP jezicima. Ipak, radi boljeg razumjevanja daljnjeg teksta potrebno ih je odvojeno definisati.U osnovi objektno-orijentisanog programiranja leži ideja objedinjavanja u jednoj strukturi podataka i akcija nad njima (koje se u terminologiji OOP nazivaju metode). To znači, pri ovakvom pristupu organizaciji podataka, za razliku od tradicionalnog, postoji uža veza između podataka i akcija. OOP omogućava efikasniji rad programera time što se kreiraju kompaktniji i lako proširivi programi. Iako će neki pojmovi OOP-a možda na prvi pogled izgledati nejasni, napor da se ovlada novim pristupom programiranju višestruko će se isplatiti. U toku 80-ih godina pojavili su se prvi komercijalni programi u kojima je realizovana nova paradigma programiranja, takozvani objektni pristup, kojim se značajno podigla produktivnost programera.
Arif Nuhanović; e-mail:[email protected]
3
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
OSNOVNE PREDNOSTI OOP
1. Objekti. U OOP metafori osnovna jedinica je objekt, implementirani objekt nazivamo klasom. U objektno orijentiranom svijetu izbjegava se korištenje globalnih varijabli, nego svaki objekt ima svoje varijable, koje još zovemo i podatkovni članovi klase. Isto tako nema više ni samostojećih funkcija, nego funkcije pripadaju klasi, bilo da vanjskom svijetu nešto kazuju o stanju objekta, ili mijenjaju stanje objekta, a zovemo ih funkcijski članovi klase ili metode.
2. Učahurivanje ili enkapsulacija objekata. Pošto ne postoje globalne varijable, iz drugih dijelova koda nije moguć pristup varijablama klase nikako osim ugrađenim metodama za njihovo čitanje i pisanje (ukoliko smo ih deklarirali kao privatne, što je preporučeno). Na taj način se osigurava da objekt ne može doći u neko nepredviđeno stanje iz bilo kojeg razloga, npr. kad mu se pristupa istovremeno iz više dijelova koda (ako imamo višenitno programiranje) jer nužno je koristiti funkcijske članove objekta u koje se mogu ugraditi sigurnosni mehanizmi poput sinkronizacije.
3. Apstrakcija - čest je slučaj da se neki objekti minimalno razlikuju, i zasebno definiranje svakog od njih je redundantno. Osim toga za samo efikasno projektiranje praktično je pojednostavljivanje konkretnog problema. Tu ulaze u igru apstraktne klase i sučelja.
4. Nasljeđivanje - kad već definiramo neki objekt, a zatreba nam neki sličan objekt koji je zapravo podskup početnog objekta, moguće je naslijediti početni objekt, čime štedimo vrijeme za programiranje (makar to bio copy-paste) i diskovni prostor.
5. Višeobličje ili polimorfizam - kao što je preopterećivanje operatora zgodna stvar ponekad, tako preopterećivanje metoda zovemo polimorfizmom. Moguće je definirati nekoliko metoda istog imena, a svaka će kao parametre primati objekte različitih tipova.
Arif Nuhanović; e-mail:[email protected]
4
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Definicija razreda (klase)Klasa (class) je korisnički definisan tip podataka koji ima stanje (svoju reprezentaciju) i neke operacije (svoje ponašanje). Klasa sadrži neke interne podatke i neke metode, u formi procedura i funkcija, i obično opisuje generičke karakteristike i ponašanje velikog broja sličnih objekata.
Objekat (object) je instanca klase, ili promjenjiva tipa podataka definisanog klasom. Objekti su stvarni entiteti. Kada se program izvršava, objekti zauzimaju dio memorije za njihove interne reprezentacije. Veza između objekata i klasa je jednaka vezi između promjenjive i tipa podataka.
Da biste deklarisali tip podataka klase u Object Pascalu sa nekim lokalnim poljima podataka i nekim metodima, upotrebite sljedeću sintaksu:
Funkcija i procedura definisane u kodu iznad trebalo bi da u potpunosti budu definisane u implementacionom dijelu iste jedinice, uključujući i deklaraciju klase. Možete dopustiti Delphiju da generiše kostur definicije metoda upotrebom funkcije editora Class Completion (jednostavno pritisnite kombinaciju tastera Ctrl+C dok se kursor nalazi unutar definicije klase). Možete naznačiti da su metodi dio klase TDate po prefiksu naziva klase (koristeći tačku između) kao u sledećem kodu:
procedure TDate.SetValue(m, d, y: Integer);begin
Month:= m; Day := d; Year:= y;
end;
function TDate.LeapYear: Boolean;begin// call IsLeapYear in SysUtils.pasResult := IsLeapYear (Year);
end;
Kada je klasa definisana, možemo kreirati objekat i koristiti ga na slijedeći način:
Arif Nuhanović; e-mail:[email protected]
typeTDate = classMonth, Day, Year: Integer;procedure SetValue (a, d, y: Integer);function LeapYear: Boolean;
end;
5
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Notacija koja se koristi nije neobična, ali je veoma moćna. Možete napisati složenu funkciju (kao što je LeapYear), a zatim dobiti njenu vrijednost za svaki objekat TDate kao da je to primitivni tip podataka. Primjetite da je izraz ADay.LeapYear sličan ADay.Year, mada je prvo poziv funkcije, a drugo direktan pristup podacima. Kao što ćemo vidjeti u narednom poglavlju, notacija koju koristi Object Pascal, da bi se pristupilo svojstvima, je ponovo ista.
Dodavanje svojstava klasi TDate
U prethodnom poglavlju smo napisali klasu TDate. Sada je možemo proširiti upotrebom svojstava. Evo nove deklaracije klase. Sada sadrži neke nove metode (koji se koriste za određivanje i dobijanje vrijednosti svojstava) i četiri svojstva:
type TDate = class private fDate: TDateTime; FOnChange: TNotifyEvent; function UzmiGodinu: Integer; function UzmiDan: Integer; function UzmiMjesec: Integer; procedure podesiDan(const Value: Integer); procedure podesiMjesec(const Value: Integer); procedure podesiGodinu(const Value: Integer); protected procedure DoChange; dynamic; public constructor Create; overload; constructor Create (y, m, d: Integer); overload; procedure podesiVrijednost (y, m, d: Integer); overload; procedure podesiVrijednost (NewDate: TDateTime); overload; function PrestupnaGodina: Boolean; procedure DodajDan (NumberOfDays: Integer = 1); procedure OduzmiDan (NumberOfDays: Integer = 1); function GetText: string; virtual; property Dan: Integer read UzmiDan write podesiDan; property Mjesec: Integer read UzmiMjesec write podesiMjesec; property Godina: Integer read UzmiGodinu write podesiGodinu; property Text: string read GetText; end;
Svojstva Godina, Dan i Mjesec čitaju i zapisuju svoje vrijednosti upotrebom odgovarajućih metoda. Evo dva koja se odnose na svojstvo Mjesec:
Arif Nuhanović; e-mail:[email protected]
varADay: TDate;
begin// createADay := TDate.Create;// useADay.Setvalue(1,1,2010); if ADay.LeapYear thenShowMessage (‘Leap year: ’+IntToStr
(ADay.Year));// destroyADay.Free;
end;
6
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
function TDate.UzmiMjesec: Integer;var y, m, d: Word;begin DecodeDate (fDate, y, m, d); Result := m;end;
procedure TDate.podesiMjesec(const Value: Integer);begin if (Value < 0) or (Value > 12) then raise EDateOutOfRange.Create ('Pogrešan Mjesec'); podesiVrijednost (Godina, Value, Dan);end;
Sada imamo klasu ažuriranu novim svojstvima te možemo ažurirati primjer tako da koristi svojstva kada je to pogodno. Na primjer, možemo direktno upotrebiti svojstvo Text i možemo upotrebiti neka polja za izmjene da bismo omogućili korisniku da pročita i upiše vrijednosti tri glavna svojstva (kao što možete vidjeti na slici ispod). Ovo se odvija kada se klikne kontrola Pročitaj:
procedure TDateForm.BtnReadClick(Sender: TObject);begin EditYear.Text := IntToStr (TheDay.Godina ); EditMonth.Text := IntToStr (TheDay.Mjesec); EditDay.Text := IntToStr (TheDay.Dan);end;
SLIKA 1: Orozor programa koji koristi klasu TData
Kontrola Zapiši obavlja obrnutu operaciju. Možete napisati kod na neki od slijedećih načina:
Arif Nuhanović; e-mail:[email protected]
7
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
procedure TDateForm.BtnWriteClick(Sender: TObject);begin
TheDay.podesiVrijednost (StrToInt (EditYear.Text), StrToInt (EditMonth.Text), StrToInt (EditDay.Text));end;
Cilj novih metoda, DodajDan i OduzmiDan (koji imaju unapred određenu vrijednost za svoje parame- tre), je veoma lako shvatiti. Ukoliko ih pozovete bez parametara, oni menjaju datum na prethodni ili naredni dan. Ukoliko je parametar NumberOfDays dio poziva, dodaje se ili oduzima taj broj.
GetText kao rezultat daje string sa formatiranim datumom upotrebom funkcije DateToStr.
Metoda UzmiGodinu iz klase Tdate uzima vrijednost godine i predaje kontroli koja ju je pozvala.
Arif Nuhanović; e-mail:[email protected]
procedure TDate.DodajDan (NumberOfDays: Integer = 1);beginfDate := fDate + NumberOfDays;// fire the eventDoChange;end;
procedure TDate.OduzmiDan (NumberOfDays: Integer = 1);beginfDate := fDate - NumberOfDays;DoChange;end;
function TDate.GetText: string;begin GetText := DateToStr (fDate);end;
function TDate.UzmiGodinu: Integer;var y, m, d: Word;begin DecodeDate (fDate, y, m, d); Result := y;end;
8
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Dodavanje događaja klasi TDate
Kao što smo dodali svojstva klasi TDate, možemo dodati i događaj. Događaj će biti veoma jednostavan. Nazvaćemo ga OnChange i može se upotrebiti da upozori korisnika komponente da je vrijednost datuma promenjena. Da bismo definisali događaj, definisaćemo svojstvo koje mu odgovara i dodaćemo neke podatke da bismo sačuvali stvarni pokazivač metoda na koji se referiše događaj. Ovo su nove definicije koje su dodate klasi:
type TDate = class private fDate: TDateTime; FOnChange: TNotifyEvent; ….protected procedure DoChange; dynamic;public …. property OnChange: TNotifyEvent read FonChange write FOnChange;end;
Definicija svojstva je, zapravo, veoma jednostavna. Korisnik ove klase može dodati novu vrijednost svojstvu i, zbog toga, privatnom polju FOnChange. Klasa ne dodeljuje vrijednost ovom polju FOnChange. Korisnik komponente je onaj koji dodeljuje vrijednost. Klasa TDate jednostavno poziva metod koji je sačuvan u polju FOnChange kada se menja vrijednost datuma. Naravno, poziv se izvršava samo ukoliko je dodjeljeno svojstvo događaja. Metod DoChange (deklarisan kao dina- mički metod jer je to uobičajeno kada događaj poziva metod) obavlja testiranje i poziv metodu:
procedure TDate.DoChange;begin if Assigned (FOnChange) then FOnChange (Self);end;
Metod DoChange se poziva svaki put kada se promjeni jedna od vrijednosti, kao što je to slučaj u sledećem metodu:
procedure TDate.podesiVrijednost (y, m, d: Integer);begin fDate := EncodeDate (y, m, d); DoChange;end;
Arif Nuhanović; e-mail:[email protected]
9
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Ukoliko sada pogledamo program koji koristi ovu klasu, možemo značajno pojednostaviti njegov kod. Prvo, dodaćemo novi metod klasi formulara:
type TDateForm = class(TForm) ….public procedure DateChange(Sender: TObject);
Kod ovog metoda jednostavno ažurira oznaku aktuelnom vrijednošću svojstva Text objekta Tdate
Ova obrada događaja se zatim instalira u metod FormCreate:
Metodi klase i podaci klase
Kada polje definišete u klasi, Vi zapravo određujete da polje treba dodati svakoj instanci objekta te klase. Svaka instanca ima svoju nezavisnu reprezentaciju (na koju se možete pozvati ključnom riječi Self). U nekim slučajevima, ipak, može da bude korisno postojanje polja koje dijele svi objekti klase.Ukoliko je potrebno da ovoj vrijednosti pristupite van jedinice, možete upotrebiti metod klase. Ipak, ovo Vas primorava da upotrebite ovaj metod na jednu od instanci klase. Alternativno rešenje je da deklarišete metod klase (class method). Metod klase ne može pristupiti podacima bilo kog pojedinačnog objekta, ali se može primjeniti na cijelu klasu umjesto na određenu instancu klase. Metod klase je povezan sa klasom, ne sa njenim instancama ili objektima (nešto kao static funkcija članica u jezicima Java i C++).
Da biste deklarisali metod klase u Object Pascalu, jednostavno dodajte ključnu riječ class ispred metoda:
Arif Nuhanović; e-mail:[email protected]
procedure TDateForm.FormCreate(Sender: TObject);begin TheDay := TNewDate.Create (1973, 3, 29); LabelDate.Caption := TheDay.GetText;
TheDay.OnChange := DateChange;end;
procedure TDateForm.DateChange;begin LabelDate.Caption := TheDay.Text;end;
10
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Upotreba metoda klase nije česta u Object Pascalu jer isti efekat možete postići dodavanjem procedure ili funkcije jedinici koja deklariše klasu. Zapravo, VCL veoma često koristi metode klase, mada postoji i veliki broj globalnih podrutina. Primetićete da u Delphiju metodi klase mogu da budu virtuelni, te se mogu zaobići i koristiti da bi se postigao polimorfizam.
Objekti
Već ranije sam definisao objekat ali u ovom poglavlju ću detaljnije objasniti svrhu i način korištenja objekata nakon što se deviniše klasa i njeni prateći elementi. U nekim OOP jezicima, deklarisanje promjenjive tipa klase kreira instancu te klase. Object Pascal se, umjesto toga, zasniva na objektnom referentnom modelu. Ideja je da svaka promjenjiva tipa klase, kao što je ADay u fragmentu koda iznad, ne sadrži vrijednost objekta. Umjesto toga sadrži referencu, ili pokazivač, kojim se označava lokacija u memoriji gde se objekat čuva.Jedini problem ovakvog pristupa je da kada deklarišete promenljivu, Vi ne kreirate objekat u memoriji; Vi samo rezervišete lokaciju memorije za referencu na objekat. Instance objekta se moraju ručno kreirati, bar za objekte klase koju definišete. Instance komponente koje smještate na formular, Delphi sam izgrađuje.
Da biste kreirali instancu objekta, možemo pozvati metod Create, koji predstavlja konstruktor. Kao što ste mogli da vidite u poslijednjem fragmentu koda, konstruktor se odnosi na klasu, a ne na objekat. Odakle dolazi metod Create? To je konstruktor klase TObject, iz koje ga nasleđuju sve ostale klase. Kada jednom kreirate objekat, i kada ste završili sa korišćenjem objekta, potrebno je da ga uklonite da biste izbjegli popunjavanje memorije objektima koji Vam više nisu potrebni, što dovodi do stanja koje se naziva “iscrpljenje memorije” (memory leak). Oslobađanje memorije se može postići pozivom metoda Free (koji predstavlja još jedan metod klase TObject), kao što je pokazano u prethodnom listingu. Sve dok kreirate objekte kada su Vam potrebni, i sve dok ih uklanjate kada Vam nisu potrebni, objektni referentni model će funkcionisati bez greške.
Ključna riječ Self
Vidjeli smo da su metodi slični procedurama i funkcijama. Suštinska razlika je u tome da metodi sadrže implicitni parametar, koji predstavlja referencu na aktuelni objekat. U okviru metoda Vi možete da se referišete na taj parametar — aktuelni objekat — koristeći ključnu riječ Self. Ovaj dodatni sakriveni parametar je potreban kada kreirate nekoliko objekata iste klase, tako da svaki put kada primjenjujete metod na neki od objekata, metod će funkcionisati samo nad sopstvenim podacima i neće uticati na ostale slične objekte.
Na primjer, u metodu SetValue klase TDate, koja je prikazana ranije, mi jednostavno koristimo
Arif Nuhanović; e-mail:[email protected]
typeMyClass = class
class function ClassMeanValue: Integer;
11
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Mjesec, Godina i Dan da bismo se referisali na polja aktuelnog objekta, nešto što možete zapisati kao
Ovako, zapravo, Delphi kompajler prevodi kod, a ne kako bi trebalo da ga Vi napišete. Ključna riječ Self je fundamentalna konstrukcija jezika, koju koristi kompajler, ali je programeri povremeno koriste da bi riješili konflikte sa nazivima i da bi učinili kod čitljivijim.
Privatni, zaštićeni i javni članovi
Klasa može sadržati bilo koju količinu podataka i bilo koji broj metoda. Ipak, za dobar objektno orijentisani pristup, podaci bi trebalo da budu sakriveni, ili enkapsulirani (encapsulated), unutar klase koja ih koristi. Kada pristupate datumu, na primjer, nema nikakvog smisla mijenjati samu vrijednost datuma. Zapravo, promena vrijednosti dana može kao rezultat dati netačan datum, recimo 30. februar. Upotreba metoda za pristup unutrašnjoj reprezentaciji objekta smanjuje rizik generisanja grešaka, jer metodi mogu provjeriti da li je datum valjan i odbiti promjenu datuma ukoliko nije. Enkapsulacija je važna jer omogućava onome ko piše klasu, da promjeni internu reprezentaciju u nekoj budućoj verziji.
Koncept enkapsulacije je veoma jednostavan: zamislite klasu kao “crnu kutiju” čiji je jedan mali dio vidljiv. Vidljivi dio, koji se naziva interfejs klase, omogućava ostalim delovima programa pristup i upotrebu objekata klase. Ipak, kada koristite objekte, većina njihovog koda je sakrivena. Rijetko ćete znati koje interne podatke objekat ima, i obično nećete imati način da direktno pristupite podacima. Naravno, pretpostavlja se da ćete Vi koristiti metode da biste pristupili podacima koji su zaštićeni od neautorizovanog pristupa. Ovo je objektno orijentisani pristup klasičnom konceptu programiranja koji je poznat kao sakrivanje informacija (information hiding).
Object Pascal sadrži tri identifikatora pristupa: private, protected i public.
četvrti, published, ćemo kasnije upoznati.
Evo tri osnovna:
1. Private - direktiva private označava polja i metode klase kojima se ne može pristupiti van jedinice (fajla izvornog koda) koja deklariše klasu.
1. Public - direktiva public označava polja i metode kojima se može slobodno pristupati iz bilo kog dijela programa kao i iz jedinice u kojoj su definisani.
2. Direktiva protected se koristi da označi metode i polja sa ograničenom vidljivošću. Samo aktuelna klasa i njene potklase mogu pristupiti elementima protected. Ponovo ćemo razmatrati ovu ključnu riječ u odeljku “Protected polja i enkapsulacija”.
Arif Nuhanović; e-mail:[email protected]
Self.Month := m; Self.Day := d;
12
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Uopšte uzev, polja klase bi trebalo da budu private; metodi su obično public. Ipak, to nije uvjek slučaj. Metodi mogu da budu private ili protected ukoliko su potrebni samo interno, da bi obavili neka djelimična izračunavanja. Polja mogu da budu protected ili public kada želite lak i direktan pristup i kada ste prilično sigurni da se njihova definicija tipa neće mijenjati.Specifikatori pristupa samo ograničavaju kod van jedinice prilikom pristupa određenim članovi- ma klasa koji su deklarisani u odeljku interfejs Vaše jedinice. To znači da ukoliko su dvije klase u okviru iste jedinice, tada ne postoji zaštita njihovih privatnih polja. Samo ukoliko smestite klasu u dio jedinice interfejs, moći ćete da ograničite vidljivost klasa i funkcija u drugim jedinicama na javne metode i polja klase.
Razmislite o ovoj novoj verziji klase TDate.
U ovoj verziji polja su deklarisana kao private i dodati su neki metodi. Prvi, GetText, je funkcija koja kao rezultat vraća string koji sadrži datum. Možda pomišljate da dodate i druge funkcije, recimo GetDay, GetMonth i GetYear, koje će jednostavno kao rezultat dati odgovarajuće private podatke, ali slične funkcije direktnog pristupa podacima nisu uvjek potrebne. Obezbeđivanje funkcija za pristup svakom polju može umanjiti enkapsulaciju i otežati izmjene interne implementacije klase. Funkcije pristupa treba obezbjediti samo ukoliko su dio logičkog interfejsa klase koju implementirate.
Drugi novi metod je procedura Increase, kojom se datum povećava na naredni dan. Ovo je daleko od jednostavnosti, jer morate uzeti u obzir različiti broj dana u mesecima, kao i prestupne godine. Ono što ću učiniti da bih olakšao pisanje koda, je promena interne imple- mentacije klase da bih mogao da upotrebim Delphijev tip TDateTime za internu implementaciju. Klasa će se promjeniti u
Primetićete da, pošto je jedina promena u private dijelu klase, nećete morati da menjate bilo kojiVaš postojeći program da biste mogli da je koristite. To je prednost enkapsulacije!
Arif Nuhanović; e-mail:[email protected]
typeTDate = class privatefDate: TDateTime;
publicprocedure SetValue (in, d, y: Integer);function LeapYear: Boolean; function GetText: string; procedure Increase;
end;
typeTDate =
class private
Month, Day, Year: Integer;public
procedure SetValue (m, d, y: Integer);function LeapYear: Boolean; function GetText: string; procedure Increase;
end;
13
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Konstruktori
Da bismo postavili memoriju za objekat, pozvaćemo metod Create. To je konstruktor, specijalni metod koji možete upotrebiti nad klasom da biste postavili memoriju za instancu klase. Konstruktor će vratiti instancu koja se može dodeliti promenljivoj, koja će čuvati objekat i koju možete kasnije koristiti. Unapred određeni konstruktor TObject.Create inicijalizuje sve podatke nove instance na nulu.
Ukoliko želite da Vaša instanca podataka započne nenultom vrijednošću, tada je potrebno da napišete svoj konstruktor koji će to učiniti. Novi konstruktor možete nazvati Create, ili mu možete dodeliti neki drugi naziv: jednostavno upotrebite ključnu riječ constructor ispred naziva. Primetićete da u tom slučaju nije potrebno pozvati TObject.Create: svaki konstruktor automatski može da postavi memoriju za instancu objekta jednostavnom upotrebom ovog speci- jalnog metoda na odgovarajuću klasu.
Osnovni razlog dodavanja sopstvenog konstruktora klasi je inicijalizacija podataka. Ukoliko objekte kreirate tako da ih ne inicijalizujete, kasniji pozivi metoda mogu kao rezultat imati čudno ponašanje ili izazvati greške prilikom izvršavanja. Umjesto da čekate da se greške jave, trebalo bi da koristite preventivne tehnike da biste ih izbjegli. Jedna od takvih tehnika je dosledna upotreba konstruktora za inicijalizaciju podataka objekata. Na primjer, moramo pozvati proceduru SetValue klase TDate poslije kreiranja objekta. Kao alternativu možemo obezbjediti prilagođeni konstruktor koji kreira objekat i dodeljuje mu početnu vrijednost.
Mada, uopšte uzev, možete dodeliti bilo koji naziv konstruktoru, imajte na umu da, ukoliko koristite naziv drugačiji od Create, konstruktor Create osnovne klase TObject će i dalje biti na raspolaganju. Ukoliko pišete i razvijate kod koji će drugi koristiti, programer koji poziva unapred određeni konstruktor, može zaobići kod koji ste Vi obezbedili. Definisanjem konstruktora Create sa nekoliko parametara Vi ćete zameniti unapred određenu definiciju novom koja će biti.
Objekti i memorija
Manipulisanje memorijom u Delphiju podliježe dvama jednostavnim pravilima: morate ukloniti svaki objekat koji kreirate, i svaki objekat morate ukloniti samo jednom. Delphi podržava tri tipa manipulisanja memorijom za dinamičke elemente (to jest, elemente koji se ne nalaze na steku i globalnoj memoriji):
Svaki put kada kreirate objekat, morate i da ga oslobodite. Ukoliko to ne učinite, memorija koju koristi objekat se neće osloboditi sve dok program ne prestane da se izvršava.
Kada kreirate komponentu, možete navesti vlasnika komponente, prosleđujući vlasnika konstruktoru komponente. Vlasnik komponente (obično formular) postaje odgovoran za uklanjanje svih objekata koje poseduje. Drugim riječima, kada oslobodite formular, on će takođe osloboditi sve komponente koje posjeduje. Dakle, ukoliko kreirate komponentu i dodjelite joj vlasnika, ne morate imati na umu da je uklonite.
Kada postavite memoriju za stringove, dinamičke nizove i objekte na koje se referiše promenljivima interfejsa, Delphi automatski oslobađa memoriju kada referenca izađe
Arif Nuhanović; e-mail:[email protected]
14
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
iz opsega. Nije potrebno da oslobodite string: kada postane nedostupan, njegova memorija se oslobađa.
Dinamičko kreiranje komponenataU Delphiju se ključna riječ Self često koristi kada je potrebno da se eksplicitno referišete na aktuelni formular u jednom od njegovih metoda. Tipičan primjer je kreiranje komponente u vreme izvršavanja, kada morate da prosledite vlasnika komponente njegovom konstruktoru Create i dodjelite istu vrijednost njegovom svojstvu Parent. (Razlika između svojstava Owner i Parent se razmatra u narednom poglavlju.) U oba slučaja je potrebno da obezbedite aktuelni formular kao parametar ili vrijednost, a najbolji način da to uradite je ključna riječ Self.
Da bih Vam demonstrirao ovaj tip koda, napisao sam primjer CreateC (naziv je potekao od Create Component). Ovaj program sadrži jednostvan formular bez komponenata i hendler za događaj OnMouseDown. Koristio sam OnMouseDown jer događaj prima parametar kao poziciju gde ste kliknuli mišem (za razliku od događaja OnClick). Ova informacija mi je bila potrebna da bih kreirao kontrolu na toj poziciji. Evo koda za metod:
Efekat ovog koda je u tome da kreira kontrole na mestima gde kliknete mišem, a naslov kontro- la predstavlja tačnu poziciju, kao što možete vidjeti na slici 2.1. U prethodnom kodu primetićete upotrebu ključne riječi Self, kao parametra metoda Create i kao vrijednost svojstva Parent.
SLIKA 2: Program koji na površini forme dinamički kreira odabranu komponentu
Arif Nuhanović; e-mail:[email protected]
procedure TForml.FormMouseDown(Sender:Tobject; Button:TMouseButton; Shift:TShiftState; X, Y:Integer);var
Btn: TButton;begin
Btn := TButton.Create (Self); Btn.Parent : Self;Btn.Left := X; Btn.Top := Y;Btn.Width := Btn.Width + 50;Btn.Caption := Format (‘Button at %d, %d’,
[X, Y]);end;
15
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
PolimorfizamPascalove funkcije i procedure se obično zasnivaju na statičkom povezivanju (static binding), koje se još naziva i ranim povezivanjem (early binding). To znači da poziv metodu rješava kompajler ili linker koji zamenjuje zahtjev pozivom određene memorijske adrese na kojoj se funkcija ili procedura nalazi. (Ovo je poznato kao adresa (address) funkcije.) Objektno orijentisani programski jezici omogućavaju upotrebu još jednog oblika povezivanja, poznatog kao dinamičko povezivanje (dynamic binding), ili kasno povezivanje (late binding). U ovom slučaju, stvarna adresa metoda koji treba pozvati se određuje u vreme izvršavanja na osnovu tipa instance koja je upotrebljena za poziv.Prednost ove tehnike je poznata kao polimorfizam (polymorphism). Polimorfizam znači da možete da napišete poziv metodu, dodeljujući ga promenljivoj, ali koji će metod zapravo Delphi pozvati, zavisi od tipa objekta na koji se odnosi promjenjiva. Delphi ne može odrediti, sve do vremena izvršavanja, pravu klasu objekta na koji se odnosi promjenjiva, prosto zbog pravila komaptibilnosti tipova koje smo razmatrali u prethodnom odeljku.Na primjer, pretpostavimo da klasa i njene potklase (recimo TAnimal i TDog) definišu isti metod, i da taj metod ima kasno povezivanje. Sada taj metod možete primjeniti na generičku promenljivu, kao što je MyAnimal, koja se u vreme izvršavanja može odnositi bilo na objekat klase TAnimal bilo na objekat klase TDog. Stvarni metod koji treba pozvati se određuje u vreme izvršavanja, već prema klasi aktuelnog objekta.
U novoj verziji, klase TAnimal i TDog sadrže novi metod Voice, koji treba da proizvede zvuk koji odabrana životinja proizvodi, i kao tekst i kao zvuk. Ovaj metod je definisan kao virtual u klasi TAnimal, a kasnije se zaobilazi kada definišemo klasu TDog, upotrebom riječi virtual i override:
Naravno, oba metoda je potrebno implementirati. Evo jednostavnog pristupa:
Arif Nuhanović; e-mail:[email protected]
typeTAnimal = class publicfunction Glas: string; virtual;
TDog = class (TAnimal)public
function Glas: string; override;
16
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
SLIKA 3: Program Animals2 koji omogućava polimorfno pozivanje metoda
Šta je efekat poziva MyAnimal.Glas? Zavisi. Ukoliko se promjenjiva MyAnimal trenutno odnosi na objekat klase TAnimal, biće pozvan metod TAnimal.Glas. Ukoliko se odnosi na klasu TDog, biće pozvan metod TDog.Glas. Ovo se dešava samo zato što je funkcija virtuelna (virtual).
Poziv MyAnimal.Glas će funkcionisati za objekat koji je instanca bilo koje klase naslednika klase TAnimal, pa čak i klase koja je definisana poslije poziva metoda ili je van djelokruga. Kompajleru nije potrebno da zna o svim klasama naslednicima da bi poziv učinio kompatibilnim; potrebna je samo klasa predak. Drugim riječima, poziv MyAnimal.Glas je kompatibilan sa svim budućim potklasama TAnimal.
Ovo je ključni tehnički razlog zašto objektno orijentisani programski jezici favorizuju fleksibilnost. Možete napisati kod koji koristi klase u okviru hijerarhije, a da ne morate da poznajete određene klase koje su dio te hijerarhije. Drugim riječima, hijerarhija i program se još uvjek mogu proširiti, čak i kada ste napisali hiljade linija koda koje ga koriste. Naravno, postoji jedan uslov, potrebno je da klase koje su naslednici hijerarhije budu pažljivo dizajnirane.
Arif Nuhanović; e-mail:[email protected]
procedure TFormAnirnals.BtnVerseClick(Sender: TObject);begin
LabelVoice.Caption := MyAnimal.Glas;end;
usesMMSystem:
function TAnimal.Glas: string;begin
Glas := ‘Glas neke životinje’; PlaySound (‘Anirn.wav’, 0, snd_Async);
end;
function TDog.Glas: string;begin
Glas := ‘Arf Arf’;PlaySound (‘dog.wav’, 0, snd_Async);
end;
17
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Program Animals2 demonstrira upotrebu ovih novih klasa i sadrži formular sličan prethodnom primjeru.
NasljeđivanjeČesto imamo potrebu da koristimo malo drugačiju verziju postojeće klase koju smo napisali ili koju nam je neko dao. Na primjer, možda je potrebno da dodate novi metod ili da malo promjenite postojeći. To lako možete učiniti izmenom originalnog koda, izuzev ukoliko želite da imate mogućnost korišćenja dvije različite verzije klase u različitim situacijama. Takođe, ukoliko je klase originalno napisao neko drugi (uključujući Borland), možda želite da Vaše izmjene čuvate odvojeno.
Tipična alternativa je da načinite kopiju originalne definicije tipa, promjenite kod da biste podržali nove mogućnosti, i dodjelite novi naziv rezultujućoj klasi. Ovo će, možda, funkcionisati, ali, takođe, može stvoriti probleme: dupliranjem koda, takođe, duplirate i greške; ukoliko želite da dodate novu funkciju, potrebno je da je dodate dva ili više puta, već prema broju kopija originalnog koda koje ste načinili. Ovaj pristup kao rezultat daje dva potpuno različita tipa podataka, tako da Vam kompajler ne može pomoći da iskoristite prednost sličnosti između dva tipa podataka.
Da biste riješili ovakve tipove problema u izražavanju sličnosti između klasa, Object Pascal Vam omogućava da definišete novu klasu direktno iz postojeće. Ova tehnika je poznata kao nasleđivanje (inheritance, ili subclassing, ili derivation) i čini jedan od fundamentalnih elemenata obejktno orijentisanih programskih jezika. Da biste nasledili od postojeće klase, potrebno je da samo naznačite klasu na početku deklaracije potklase. Na primjer, Delphi to čini automatski svaki put kada kreirate novi formular:
Ova jednostavna definicija označava da klasa TForm1 nasleđuje sve metode, polja, svojstva i događaje od klase TForm. Možete upotrebiti bilo koji javni metod klase TForm nad objektom tipa Tform1. TForm će odmah naslediti neke od svojih metoda od neke druge klase i tako dajle, sve do klase TObject.
Kao jednostavan primjer nasleđivanja možemo malo izmjeniti program ViewDate, izvodeći ga iz klase TDate i mjenjajući jednu od funkcija, funkciju GetText.
U ovom primjeru, TNewDate je izveden iz TDate. Uobičajeno je reći da je TDate predak
Arif Nuhanović; e-mail:[email protected]
typeTNewDate = class (TDate)public
function GetText: string;end;
typeTForm1 = class(TForm)
end;
18
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
(ancestor) ili roditelj (parent) klase TNewDate i da je TNewDate potklasa (subclass), klasa-naslednik (descendant) ili dijete-klasa (child) klase TDate.
Da bih implementirao novu verziju funkcije GetText, ja sam upotrebio funkciju FormatDateTime, koja koristi (između ostalog) unapred određene nazive mjeseci koji su dostupni pod Windowsom; ovi nazivi zavise od korisničkog podešavanja regiona i jezika. Mnoge od ovih vrijednosti Delphi, zapravo, kopira u konstante definisane u biblioteci, kao što su LongMonthNames, ShortMonthNames i mnoge druge koje možete pronaći pod temom Currency and dat/time formatting variables u Delphi Help fajlu. Evo metoda GetText, gde ‘dddddd’ označava dugački format podatka:
metodom. Izvorni kod svih ostalih događaja ostaje isti, mada mu se značenje bitno menja, kao što to novi izlaz pokazuje.
SLIKA 4: Program prikazuje korištenje funkcije “GetText” u nasljednoj klasi “TNewDate”
U program klassinfo prikazata je hierarhija klasa u Delphiu za neke često korištene objekte I komponente.
Arif Nuhanović; e-mail:[email protected]
function TNewDate.GetText: string;begin
GetText := FormatDateTime (‘dddddd’, fDate);end;
19
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
SLIKA 5: Program prikazuje hierarhiju neki od klasa u Delphiu
Arif Nuhanović; e-mail:[email protected]
20
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
PREGLED OBJEKTNO ORJENTISANI PROGRAMSKIH JEZIKADanas gotovo da nema ozbiljnijeg programskog jezika koji nema podršku za objekte. U nastavku ću navesti neko najpoznatije koji se danas najviše koriste a podržavaju OOP.
C++Programski jezik C++ je programski jezik opće namjene i srednje razine s podrškom za objektno orijentirano programiranje. Prvotno je razvijan u Bell Labs (laboratoriju telekomunikacijske tvrtke Bell) pod rukovodstvom Bjarne Stroustrupa tokom 1980-ih kao proširenje programskom jeziku C, te mu je originalno ime bilo "C with classes" (engl. C s klasama). Zbog velike potražnje za objektno orijentiranim jezicima te izrazitim sposobnostima, specifikacija programskog jezika C++ ratificirana je 1998. kao standard ISO/IEC 14882.
Povijest razvojaGodine 1980., Bjarne Stroustrup, iz Bell Labova, počeo je razvoj C++ jezika, koji će formalno dobit ovaj naziv krajem 1983. U oktobru 1985. godine, prva komercijalna distribucija jezika predstavljena je javnosti u knjizi "The C++ Programming Language" čiji je autor Bjarne Stroustrupa.
Java (programski jezik)
Java je objektno orijentirani programski jezik koji su razvili James Gosling, Patrick Naughton i drugi inženjeri u tvrtci Sun Microsystems. Razvoj je počeo 1991, kao dio projekta Green, a objavljen je u novembru 1995.
Tvrtka Sun posjeduje trademark na ime Java, ali samo okruženje je moguće bez plaćanja skinuti sa Sunovih internet servera.
Velika prednost u odnosu na većinu dotadašnjih programskih jezika je to što se programi pisani u Javi mogu izvoditi bez prepravke na svim operativnim sustavima za koje postoji JVM (Java Virtual Machine), dok je klasične programe pisane primjerice u C-u potrebno prilagođavati platformi(Operacijskom sustavu) na kojem se izvode.
Time i bogatim skupom klasa za rad s mrežnim komunikacijama u jednom trenutku je Java bila najbolji izbor za široku lepezu mogućih aplikacija. Microsoft je stoga razvio svoj C# i .NET platformu kao odgovor na open source alternative.
C sharp
C# je objektno orijentirani programski jezik kojeg su razvili Anders Hejlsberg i drugi u tvrtci Microsoft.
C# je izumljen s ciljem da .NET platforma dobije programski jezik, koji bi maksimalno iskoristio njezine sposobnosti. Sličan je programskim jezicima Java i C++.
Arif Nuhanović; e-mail:[email protected]
21
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
PythonPython je prevođeni programski jezik kojeg je stvorio Guido van Rossum 1990. godine, ime dobiva po televiziskoj seriji Monty Python's Flying Circus.. Po automatskoj memorijskoj alokaciji, Python je sličan programskim jezicima kao što su Perl, Ruby, Smalltalk itd. Python dopušta programerima korištenje nekoliko stilova programiranja. Objektno orijentirano, strukturno i aspektno orijentirano programiranje stilovi su dopušteni korištenjem Pythona te ova fleksiblinost čini Python programski jezik sve popularnijim. Python se najviše koristi na Linuxu, no postoje I verzije za druge operacijske sustave.
Visual BasicVisual Basic (VB) je programski jezik kojeg je razila tvrtka Microsoft i on je programski jezik za programiranje radnji (event drive) kao i radno sučelje (development environment). Ovo je iznimno popularna verzija Basica, nudi jednostavnost Basic jezika zajedno s potpunim pristupom Windows API-ju čime je omogućena izrada svih vrsta aplikacija s velikim mogućnostima. VB omogućava brzu izradu aplikacija (Rapid Application Development ili RAD) koje imaju grafički međuskop s korisnikom (GUI); također omogućava pristup datotekama rabeći DAO, RDO ili ADO, te omogućava programeru stvaranje Active X komponenti s relativnom lakoćom.
Nedostaci
Samo je dostupan za Windows. Nedostaci Visual Basica su ovisnost konačnog programa o određenim Visual Basic datotekama (runtime datoteke koje su nužne za pokretanje programa) što povećava veličinu instalacije te nešto manja brzina izvršavanja završene aplikacije u odnosu na neke druge programske jezike.
U VB-u nije moguće:
implementation inheritance (postavka objektnog programiranja) sto je pak uvedeno u VB .NET -u
programirati rutine za hvatanje posebnih događuaja (exception handling) koristiti pokazivače kao u programskom jeziku C
Visual Basic je jako popularan kao programski jezik jer vuče korijene iz BASIC-a, jednog od najpopularnijih programskih jezika tokom 80-tih i on je osnovni programski jezik na kojemu su stvorene mnoge Microsoft aplikacije: Microsoft Word, Microsoft Excel i Microsoft PowerPoint.
Pascal (programski jezik)Pascal je ime programskog jezika kojeg je stvorio švicarski znanstvenik Niklaus Wirth 1970. godine. Isprva se Pascal koristilo kao nastavno pomagalo za strukturalnu metodu programiranja računala na fakultetima. Tokom 80ih i ranih 90ih godina 20. stoljeća Pascal se proširio van akademskih krugova u industriju, no ubrzo nakon pojave i masivnijom upotrebom objektno orijentiranih jezika kao C++ ili Java tjekom sredine 90ih godina 20. stoljeća, Pascal počinje gubiti primat u školama kao i u industriji. Pokušaj proširivanja Pascala s objektno
Arif Nuhanović; e-mail:[email protected]
22
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
orijentiranim konceptima kroz Object Pascal i kasnije kroz programski jezik Delphi uspjele su prilagoditi Pascal novim izazovima, no njegova popularnost sve više opada.
Povijest razvoja
Pascal je programski jezik razvijen 1970. godine od strane Niklausa Wirtha kao jezik posebno pogodan za strukturalno programiranje (za razliku od danas opće prihvaćene OOP metode). Baziran na temeljima programskog jezika Algol dobio je ime u čast matematičara i filozofa Blaisea Pascala.
Iako je inicijalno bio zamišljen kao jezik namijenjen učenju programiranja u školama i univerzitetima širom svijeta danas se koristi u industriji razvoja softwarea u svojoj najpoznatijoj inkarnaciji - Object Pascal, Delphi. Delphi je razvijen od strane korporacije Borland za svestrani razvoj aplikacija od sistemskih alata i igara do desktop, database i višeslojnih kompleksnih aplikacija za (CP/M, MS-DOS i MS Windows 3.xx u prošlosti...) i MS Windows/.Net i Linux platforme.
Prvu implementaciju Pascala napravio je Niklaus Wirth za računalo CDC 6000 1970. u Zürichu, dok je prvi program prevodilac za Pascal napisan u SAD-u bio stvoren na University of Illinois u nadležnosti Donalsa B. Gilliesa za porodicu računala DEC PDP-11 u assembleru. Niklaus Wirth je olakšao presađivanje Pascala na druga računala tako što je stvorio kit za portiranje, što je imalo za cilj da smanji količinu posla potrebnog za stvaranje programa prevodioca s jedne porodice računala na druga. Misao je bila da program prevodilac za Pascal pretvori sve naredbe u jedan virtualni assembler, i tako da je programer samo trebao stvoriti program koji bi preveo taj virtualni assembler za ciljani računski stroj ili stvori simulator za virtualnu mašinu za ciljani stroj. Ovaj međustupanj postaje P-sistem.
Usporedba Object Pascala i ostalih objektno orijetiranih jezika
Object Pascal/Delphi danas predstavlja vrh u razvoju softwarea. Programski jezik slijedi OOP principe i dodaje mnoštvo ekstenzija koje se mogu naći u najpoznatijim C/C++/C Sharp|C#]] jezicima, kao što su operator overloading, method overloading, inline methods, "rich" records (record s method-ima), etc...
Delphijev kompajler slovi kao najbrži kompajler među programskim jezicima u industriji softwarea (kompajliranje u izvršni program stotina tisuća linija koda traje samo nekoliko sekundi za razliku od tipičnih C/C++ kompajlera) proizvodeći pritom optimiziran kod brzine usporedive s najboljim C/C++ kompajlerima.
Danas (Object) Pascal koristi preko milijun profesionalnih programera širom svijeta, a najnovije izdanje (Borland) Delphi 2006 unosi cijeli niz noviteta u razvojno okruženje (IDE). Tu se mogu naći UML modeliranje softwarea, integracija s alatima za configuration management (npr. Borland StarTeam), integracija s alatima za requirements management (npr. Borland Caliber), alatima za optimizaciju itd itd...
Arif Nuhanović; e-mail:[email protected]
23
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Arif Nuhanović; e-mail:[email protected]
24
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Zaključak
Objektno orijentisano programiranje (OOP) u računarstvu je jedna od programskih paradigmi. Od ranih 1980-tih pa do danas ova paradigma je postala najuticajnija paradigma u komercijalnom razvoju softvera. Programski jezici poput C++ i Java programski jezik su svojom popularnošću utvrdili vodeći status OOP-a kao de facto obaveznog pristupa pri razvoju softvera danas, te i jezici koji tradicionalno nisu bili objektno orijentirani su naknadno dodali OOP koncepte (npr. Visual Basic, Pascal programski jezik itd.).
Arif Nuhanović; e-mail:[email protected]
25
Seminarski rad: Principi programiranja – Objektno orjentisano programiranje
Literatura:
1. Paul Kimmel, Delphi 6, Vodič za programere, Mikro knjiga, Beograd2. Marco Cantu, Delph 5 Majstor, 3. http://hr.wikipedia.org/wiki/Objektno_orijentirano_programiranje 4. Razni internet izvori
Arif Nuhanović; e-mail:[email protected]
