PANEVROPSKI UNIVERZITET APEIRON

BANJA LUKA

Vanredne studije
Smjer „ Nastavnička informatika“

Predmet: Principi programiranja

Tema:
“Objektno orjetisano programiranje“

Predmetni nastavnik
Prof. Dr Zoran Ž. Avramović dipl. ing.elektrotehnike

Student
Arif Nuhanović
Index.br. 134-09/VNI

Banja Luka, Maj 2010. god.

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Sadržaj
Uvod............................................................................................................................................2
OSNOVNE PREDNOSTI OOP.......................................................................................................3
Definicija razreda (klase).............................................................................................................4
Dodavanje svojstava klasi TDate.........................................................................................5
Dodavanje događaja klasi TDate........................................................................................8
Metodi klase i podaci klase.................................................................................................9
Objekti.......................................................................................................................................10
Ključna riječ Self....................................................................................................................10
Privatni, zaštićeni i javni članovi............................................................................................11
Konstruktori.........................................................................................................................13
Objekti i memorija...............................................................................................................13
Dinamičko kreiranje komponenata.....................................................................................14
Polimorfizam.............................................................................................................................15
Nasljeđivanje.............................................................................................................................17
PREGLED OBJEKTNO ORJENTISANI PROGRAMSKIH JEZIKA......................................................20
C++............................................................................................................................................20
Povijest razvoja.....................................................................................................................20
Java (programski jezik)..............................................................................................................20
C sharp......................................................................................................................................20
Python.......................................................................................................................................21
Visual Basic................................................................................................................................21
Nedostaci...............................................................................................................................21
Pascal (programski jezik)...........................................................................................................21
Povijest razvoja.....................................................................................................................22
Usporedba Object Pascala i ostalih objektno orijetiranih jezika..........................................22
Zaključak...................................................................................................................................24
Literatura:.................................................................................................................................25

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 1

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Uvod
Objektno 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:arif.nuhan@gmail.com 2

 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:arif.nuhan@gmail.com 3

 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:

type
TDate = class
Month, Day, Year: Integer;
procedure SetValue (a, d, y: Integer);
function LeapYear: Boolean;
end;

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.pas
Result := IsLeapYear (Year);
end;

Kada je klasa definisana, možemo kreirati objekat i koristiti ga na slijedeći način:

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 4

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

var
ADay: TDate;
begin
// create
ADay := TDate.Create;
// use
ADay.Setvalue(1,1,2010);
if ADay.LeapYear then
ShowMessage (‘Leap year: ’+IntToStr (ADay.Year));
// destroy
ADay.Free;
end;

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:arif.nuhan@gmail.com 5

 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:

procedure TDateForm.BtnWriteClick(Sender: TObject);

begin

TheDay.podesiVrijednost (StrToInt (EditYear.Text),

StrToInt (EditMonth.Text), StrToInt (EditDay.Text));
end;

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 6

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

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.

procedure TDate.DodajDan (NumberOfDays: Integer = 1);

begin
fDate := fDate + NumberOfDays;
// fire the event
DoChange;
end;

procedure TDate.OduzmiDan (NumberOfDays: Integer = 1);

begin
fDate := fDate - NumberOfDays;
DoChange;
end;

GetText kao rezultat daje string sa formatiranim datumom upotrebom funkcije DateToStr.

function TDate.GetText: string;

begin
GetText := DateToStr (fDate);
end;

Metoda UzmiGodinu iz klase Tdate uzima vrijednost godine i predaje kontroli koja ju je
pozvala.

function TDate.UzmiGodinu: Integer;

var
y, m, d: Word;
begin
DecodeDate (fDate, y, m, d);
Result := y;
end;

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

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 7

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

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:arif.nuhan@gmail.com 8

 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

procedure TDateForm.DateChange;
begin
LabelDate.Caption := TheDay.Text;
end;

Ova obrada događaja se zatim instalira u metod FormCreate:

procedure TDateForm.FormCreate(Sender: TObject);

begin
TheDay := TNewDate.Create (1973, 3, 29);
LabelDate.Caption := TheDay.GetText;

TheDay.OnChange := DateChange;
end;

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:arif.nuhan@gmail.com 9

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

type
MyClass = class
class function ClassMeanValue: Integer;

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

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 10

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

jednostavno koristimo
Mjesec, Godina i Dan da bismo se referisali na polja aktuelnog objekta, nešto što možete
zapisati kao
Self.Month := m;
Self.Day := d;

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

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 11

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

ćemo razmatrati ovu ključnu riječ u odeljku “Protected polja i enkapsulacija”.

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.

type
TDate = class private
Month, Day, Year: Integer;
public
procedure SetValue (m, d, y: Integer);
function LeapYear: Boolean;
function GetText: string;
procedure Increase;
end;

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
type
TDate = class private
fDate: TDateTime;
public
procedure SetValue (in, d, y: Integer);
function LeapYear: Boolean;
function GetText: string;
procedure Increase;
end;

Primetićete da, pošto je jedina promena u private dijelu klase, nećete morati da menjate bilo
koji

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 12

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Vaš postojeći program da biste mogli da je koristite. To je prednost enkapsulacije!

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.

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 13

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

 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
iz opsega. Nije potrebno da oslobodite string: kada postane nedostupan, njegova
memorija se oslobađa.

Dinamičko kreiranje komponenata

U 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:

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;

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.

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 14

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

SLIKA 2: Program koji na površini forme dinamički kreira odabranu komponentu

Polimorfizam
Pascalove 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:

type
TAnimal = class
public
function Glas: string; virtual;

TDog = class (TAnimal)

public
function Glas: string; override;

Naravno, oba metoda je potrebno implementirati. Evo jednostavnog pristupa:

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 15

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

uses
MMSystem:

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;

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.

procedure TFormAnirnals.BtnVerseClick(Sender: TObject);

begin
LabelVoice.Caption := MyAnimal.Glas;
end;
Arif Nuhanović; e-mail:arif.nuhan@gmail.com 16
 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:

type
TForm1 = class(TForm)
end;

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.

type
TNewDate = class (TDate)
public
function GetText: string;
end;

U ovom primjeru, TNewDate je izveden iz TDate. Uobičajeno je reći da je TDate predak

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 17

 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:

function TNewDate.GetText: string;

begin
GetText := FormatDateTime (‘dddddd’, fDate);
end;

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:arif.nuhan@gmail.com 18

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

SLIKA 5: Program prikazuje hierarhiju neki od klasa u Delphiu

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 19

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

PREGLED OBJEKTNO ORJENTISANI PROGRAMSKIH JEZIKA

Danas 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 razvoja
Godine 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:arif.nuhan@gmail.com 20

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Python
Python 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 Basic
Visual 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:arif.nuhan@gmail.com 21

 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:arif.nuhan@gmail.com 22

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 23

 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:arif.nuhan@gmail.com 24

 Seminarski rad: Principi programiranja – Objektno orjentisano
programiranje

Literatura:

1. Paul Kimmel, Delphi 6, Vodič za programere, Mikro knjiga, Beograd

2. Marco Cantu, Delph 5 Majstor,
3. http://hr.wikipedia.org/wiki/Objektno_orijentirano_programiranje
4. Razni internet izvori

Arif Nuhanović; e-mail:arif.nuhan@gmail.com 25