Docsity
Docsity

Pripremite ispite
Pripremite ispite

Studirajte zahvaljujući brojnim resursima koji su dostupni na Docsity-u


Nabavite poene za preuzimanje
Nabavite poene za preuzimanje

Zaradite bodove pomažući drugim studentima ili ih kupite uz Premium plan


Školska orijentacija
Školska orijentacija


Objektno orjetisanje programiranja, Seminarski radovi od Informatika

Objektno orijentirano programiranje ili kraće OOP je jedan od mogućih pristupa programiranju računara.

Tipologija: Seminarski radovi

2022/2023

Učitan datuma 22.07.2025.

daketa-kronic
daketa-kronic 🇸🇷

4 dokumenti

1 / 27

Toggle sidebar

Ova stranica nije vidljiva u pregledu

Ne propustite važne delove!

bg1
UNIVERZITET “MB” BEOGRAD
POSLOVNI I PRAVNI FALKUTET
SEMINARSKI RAD
PREDMET:
OBJEKTNO ORIJENTISANO PROGRAMIRANJE
STUDENT:
DALIBOR KOSTIC
Br. Indexa: 83/2023
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b

Delimični pregled teksta

Preuzmite Objektno orjetisanje programiranja i više Seminarski radovi u PDF od Informatika samo na Docsity!

UNIVERZITET “MB” BEOGRAD

POSLOVNI I PRAVNI FALKUTET

SEMINARSKI RAD

PREDMET :

OBJEKTNO ORIJENTISANO PROGRAMIRANJE

STUDENT:

DALIBOR KOSTIC

Br. Indexa: 83/

Sadržaj

  • Sadržaj......................................................................................................................
  • Uvod....................................................................................................................
  • OSNOVNE PREDNOSTI OOP................................................................................
  • Definicija razreda (klase)..............................................................................................
    • Dodavanje svojstava klasi TDate......................................................................
    • Dodavanje događaja klasi TDate......................................................................
    • Metodi klase i podaci klase....................................................................................
  • Objekti................................................................................................................................
    • Ključna reč Self...............................................................................................................
    • Privatni, zaštićeni i javni članovi..............................................................................
    • Konstruktori.......................................................................................................
    • Objekti i memorija......................................................................................................
  • Dinamičko kreiranje komponenata....................................................................
  • Polimorfizam........................................................................................................
  • Nasljeđivanje........................................................................................................
  • PREGLED OBJEKTNO ORJENTISANI PROGRAMSKIH JEZIKA..........................
    • Povijest razvoja............................................................................................................
  • Java (programski jezik)...................................................................................................
  • C sharp...................................................................................................................
  • Python....................................................................................................................
  • Visual Basic............................................................................................................
    • Nedostaci...........................................................................................................
  • Pascal (programski jezik)....................................................................................
    • Povijest razvoja............................................................................................................
    • Usporedba Object Pascala i ostalih objektno orijetiranih jezika......................
  • Zaključak................................................................................................................
  • Literatura...............................................................................................................

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.

  1. 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.

  1. 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.

  1. 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.

  1. 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.

type TDate= class Month,Day,Year:Integer; function LeapYear:Boolean; end;

proce dure SetValue (a,d, y: Integer);

proce dure TDate.SetValue(m,begin Month := m; Day := d; Year:=y; end;

function TDate.LeapYear:

d, y: Integer);

begin

Boolean;

Result:= IsLeapYear(Year);

/ ca l IsLeapYear in SysUtils.pas

end;

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:

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

procedure TDateForm.BtnReadClick(Sender: TObject); begin EditYear.Text := IntToStr (TheDay.Godina ); EditMonth.Text := IntToStr (TheDay.Mjesec); EditDay.Text := IntToStr (TheDay.Dan);

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 Tex t i

možemo upotrebiti neka polja za izmjene da bismo omogućili korisniku da pročita i upiše

vrednosti tri glavna svojstva (kao što možete videti na slici ispod).

Ovo se odvija kada se klikne kontrola Pročitaj:

SLIKA 1: Orozor programa koji koristi klasu TData

Kontrola Zapiši obavlja obrnutu operaciju. Možete napisati kod na neki od sledećih načina:

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

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;

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;

Cilj novih metoda, DodajDan i OduzmiDan (koji imaju unapred određenu vriednost za

svoje parametre), 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.

GetTex t kao rezultat daje string sa formatiranim datumom upotrebom funkcije DateToStr.

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

procedure TDateForm.BtnWriteClick(Sender: TObject); begin

TheDay.podesiVrijednost (StrToInt (EditYear.Text), StrToInt (EditMonth.Text),

type TDateForm = class(TForm)

…. publ ic

procedure TDateForm.DateChange; begin LabelDate.Caption :=

TheDay.Text; end;

procedure TDateForm.FormCreate(Sender: TObject); begin

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

TheDay.OnChange := DateChange;

type MyCla s = class cla s function Cla s MeanValue: Integer;

pojednostaviti njegov kod. Prvo, dodaćemo novi metod klasi formulara:

Kod ovog metoda jednostavno ažurira oznaku aktuelnom vrednošću svojstva Text objekta

Tdate

Ova obrada događaja se zatim instalira u metod FormCreat e:

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 reči Self ). U nekim slučajevima, ipak, može da bude korisno postojanje

polja koje dele svi objekti klase.

Ukoliko je potrebno da ovoj vrednosti 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 celu klasu umesto na određenu

instancu klase. Metod klase je povezan sa klasom, ne sa njenim instancama ili objektima

(nešto kao stati c funkcija članica u jezicima Java i C++).

Da biste deklarisali metod klase u Object Pascalu, jednostavno dodajte ključnu riječ clas s

ispred metoda:

Self.Month : = m; Self.Day

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 promenjive tipa klase kreira instancu te klase. Object

Pascal se, umjesto toga, zasniva na objektnom referentnom modelu.Ideja je da svaka

promenjiva tipa klase, kao što je ADay u fragmentu koda iznad, ne sadrži vrednost

objekta. Umesto 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 smeš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

TObjec t, 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 izbegli 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 Fre e (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

Videli 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 SetValu e klase TDate, koja je prikazana ranije, mi

jednostavno koristimo

Mesec, Godina i Dan da bismo se referisali na polja aktuelnog objekta, nešto što možete

zapisati kao

type

Month,Day,Year:Integer; pub li c

TDate= class private

proce dure SetValuefunction LeapYear: function GetText:proce dure Increase; Boolean; string;

(m,d, y: Integer);

end;

type

fDate:TDateTime; pub li c proce dure SetValue function LeapYear: function GetText:proce dure Increase;

end;

TDate= class private

(in,d, y: Integer);Boolean; string;

tipa neće menjati. Specifikatori pristupa samo ograničavaju kod van jedinice prilikom pristupa određenim članovima klasa koji su deklarisani u odeljku interfejs Vaše jedinice. To znači da ukoliko su dve 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 uvek potrebne. Obezbeđivanje funkcija za pristup svakom polju može umanjiti enkapsulaciju i otežati izmene interne implementacije klase. Funkcije pristupa treba obezbediti 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 implementacije klase da bih mogao da upotrebim Delphijev tip TDateTime za internu implementaciju. Klasa će se promeniti u

Primetićete da, pošto je jedina promena u private delu klase, nećete morati da menjate bilo koji 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 vrednošć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 reč 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 specijalnog 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. Umesto 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 posle kreiranja objekta. Kao alternativu

možemo obezbediti prilagođeni konstruktor koji kreira objekat i dodeljuje mu početnu

vrednost.

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 podleže dvema 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 rečima, kada oslobodite formular, on će takođe osloboditi sve komponente koje poseduje. Dakle, ukoliko kreirate komponentu i dodelite 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 iz opsega. Nije potrebno da oslobodite string: kada postane nedostupan, njegova memorija se oslobađa.

Dinamičko kreiranje komponenata

U Delphiju se ključna reč Self često koristi kada je potrebno da se eksplicitno referišete na

type TAnimal pub li c

= class function Glas: (^) string; virtual;

TDog = class (TAnimal) pub li c

function Glas: string; ove r ide;

uses MMSystem: function TAnimal.Glas: begin (^) string;

Glas:= ‘Glasneke

end;

PlaySound(‘Anirn.wav’, 0, snd_Async);

životinje’;

function TDog.Glas: begin

string;

Glas:= ‘Arf Arf ’; PlaySound(‘dog.wav’, 0, snd_Async); end;

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 promenjiva,

prosto zbog pravila komaptibilnosti tipova koje smo razmatrali u prethodnom odeljku.

Na primer, 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 primeniti 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

virtua l u klasi TAnima l, a kasnije se zaobilazi kada definišemo klasu TDog, upotrebom

reči virtua l i override:

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

proce dure TFormAnirnals.BtnVerseClick(Sender: begin TObject);

LabelVoice.Caption := MyAnimal.Glas; end;

SLIKA 3: Program Animals2 koji omogućava polimorfno pozivanje metoda

Šta je efekat poziva MyAnimal.Glas? Zavisi. Ukoliko se promenjiva 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 (virtua l).

Poziv MyAnimal.Glas će funkcionisati za objekat koji je instanca bilo koje klase

naslednika klase TAnimal, pa čak i klase koja je definisana posle poziva metoda ili je van

delokruga. Kompajleru nije potrebno da zna o svim klasama naslednicima da bi

poziv učinio kompatibilnim; potrebna je samo klasa predak. Drugim rečima, poziv

MyAnimal.Glas je kompatibilan sa svim budućim potklasama TAnima l.

Ovo je ključni tehnički razlog zašto objektno orentisani 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 reč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.

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 primer, možda je potrebno da dodate novi metod ili da malo

promenite postojeći. To lako možete učiniti izmenom originalnog koda, izuzev ukoliko

želite da imate mogućnost korišćenja dve 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 izmene čuvate odvojeno.

function TNewDate.GetText: begin

GetText

string; := FormatDateTime(‘ddddd d’, 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.

SLIKA 5: Program prikazuje hierarhiju neki od klasa u Delphiu

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šte namene i srednje nivoje

s podrškom za objektno orijentirano programiranje. Prvo je razvijen u Bell

Labs (laboratoriju telekomunikacijske preduzeće 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.

Početak razvoja

Godine 1980., Bjarne Stroustrup, iz Bell Labova, počeo je razvoj C++ jezika,

koji će formalno dobiti 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.

Preduzeće Sun poseduje 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 primeri 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