mechanisms of aggregation in object-oriented programming

SVEUČILIŠTE U ZAGREBU

FAKULTET ORGANIZACIJE I INFORMATIKE

V A R A Ž D I N

Davor Vučina

MEHANIZMI AGREGACIJE U OBJEKTNO-ORIJENTIRANIM PROGRAMSKIM JEZICIMA

ZAVRŠNI RAD

Varaždin, 2014.

SVEUČILIŠTE U ZAGREBU

FAKULTET ORGANIZACIJE I INFORMATIKE

V A R A Ž D I N

Davor Vučina

Redoviti student

Broj indeksa: 39138/10-R

Smjer: Informacijski sustavi

Preddiplomski studij

MEHANIZMI AGREGACIJE U OBJEKTNO-ORIJENTIRANIM PROGRAMSKIM JEZICIMA

ZAVRŠNI RAD

Mentor:

Dr. sc. Tihomir Orehovački

Varaždin, rujan 2014.

I

Sadržaj

1. UVOD ..................................................................................................................................................................... 1

2. POVIJEST OBJEKTNO-ORIJENTIRANOG PROGRAMIRANJA .............................................................. 3

3. OBJEKTNO-ORIJENTIRANI PROGRAMSKI JEZICI ................................................................................. 6

3.1 C++ .................................................................................................................................................................... 6 3.1.1 Code::Blocks ............................................................................................................................................. 7 3.1.2 Programski primjer .................................................................................................................................... 8

3.2 C#....................................................................................................................................................................... 9 3.2.1 Microsoft Visual Studio 2012 ................................................................................................................. 10 3.2.2 Programski primjer .................................................................................................................................. 11

3.3 JAVA ................................................................................................................................................................. 12 3.3.1 NetBeans ................................................................................................................................................. 14 3.3.2 Programski primjer .................................................................................................................................. 15

3.4 PYTHON ............................................................................................................................................................ 16 3.4.1 IDLE (Python GUI) ................................................................................................................................. 17 3.4.2 Programski primjer .................................................................................................................................. 17

3.5 DELPHI ............................................................................................................................................................. 18 3.5.1 Embarcadero Delphi XE7 ....................................................................................................................... 18 3.5.2 Programski primjer .................................................................................................................................. 19

4. MEHANIZMI AGREGACIJE ........................................................................................................................... 20

4.1 POLJE................................................................................................................................................................ 20 4.1.1 C++.......................................................................................................................................................... 20 4.1.2 C# ............................................................................................................................................................ 21 4.1.3 Java .......................................................................................................................................................... 22 4.1.4 Python ..................................................................................................................................................... 23 4.1.5 Delphi ...................................................................................................................................................... 24

4.2 ZNAKOVNI NIZ .................................................................................................................................................. 24 4.2.1 C++.......................................................................................................................................................... 25 4.2.2 C# ............................................................................................................................................................ 25 4.2.3 Java .......................................................................................................................................................... 26 4.2.4 Python ..................................................................................................................................................... 27 4.2.5 Delphi ...................................................................................................................................................... 28

4.3 STRUKTURA ...................................................................................................................................................... 29 4.3.1 C++.......................................................................................................................................................... 30 4.3.2 C# ............................................................................................................................................................ 31 4.3.3 Java .......................................................................................................................................................... 31 4.3.4 Python ..................................................................................................................................................... 32 4.3.5 Delphi ...................................................................................................................................................... 33

4.4 KLASA .............................................................................................................................................................. 33 4.4.1 C++.......................................................................................................................................................... 34 4.4.2 C# ............................................................................................................................................................ 35 4.4.3 Java .......................................................................................................................................................... 35 4.4.4 Python ..................................................................................................................................................... 36 4.4.5 Delphi ...................................................................................................................................................... 37

4.5 UNIJA (C++) ..................................................................................................................................................... 38

5. ZAKLJUČAK ...................................................................................................................................................... 40

LITERATURA .......................................................................................................................................................... 43

1

1. Uvod

U računalnoj znanosti pojam programiranje odnosi se na pisanje naredbi u nekom programskom

jeziku. Programiranje je umjetnost pisanja računalnih programa. Programskih jezika i

programskih paradigmi ima mnogo, a njihova zajednička značajka je da se sastoje od skupa

naredbi i pravila [Galešev et. al., 2006].

U ovom radu obrađeni su mehanizmi agregacije u različitim objektno-orijentiranim programskim

jezicima. Mehanizmi agregacije koji se spominju su: polje, znakovni niz, struktura, klasa i unija,

a implementirani su u jezicima: C++, C#, Java, Python i Delphi.

Objektno-orijentirano programiranje danas je vrlo popularno, te postoje brojni jezici koji koriste

objektno-orijentiranu paradigmu, poput jezika C++, C#, Java, Python, Delphi, Eiffel, Lua, PHP,

Ruby, Visual Prolog, itd. Programi napisani u objektno-orijentiranim jezicima temeljni su na

objektima koji međusobno razmjenjuju poruke. U ovom radu govorit će se o povijesti i nastanku

objektno-orijentiranih jezika, te o jezicima koji su utjecali na njihov nastanak.

Svaki složeniji program u bilo kojem objektno-orijentiranom programskom jeziku koristi jedan

ili više tipova mehanizama agregacije. Mehanizmi agregacije su složeni tipovi podataka koji su

logički nedjeljivi. Oni se formiraju od jednostavnijih tipova podataka i složenih tipova niže

razine [Radošević, 2007]. U nastavku će se obraditi različiti mehanizmi agregacije u različitim

objektno-orijentiranim programskim jezicima. Odabrani objektno-orijentirani jezici su: C++,

C#, Java, Python i Delphi. Jedan od glavnih razloga odabira navedenih jezika je njihova

popularnost. Zbog te popularnosti osobama koje počinju učiti programirati, teško se odlučiti za

određeni programski jezik. Upravo stoga su opisane glavne karakteristike, povijest, te razvojno

okruženje svakog od navedenog jezika. U svakom jeziku napisan je jednostavan primjer

programa koji ispisuje poruku “Hello World!” na kojem se mogu uočiti osnovne razlike u

jezicima, poput biblioteka koje je u nekim jezicima potrebno uključiti, načina na koji program

započinje s izvršavanje, itd.

U ovom radu obrađeni su sljedeći mehanizmi agregacije: polje, znakovni niz, struktura, klasa i

unija. Svaki od navedenih mehanizama je detaljno opisan. U ranije spomenutim programskim

jezicima implementirani su primjeri koji prikazuju način korištenja mehanizama agregacije.

Primjeri su napisani u svim jezicima na identičan način kako bi se uočile razlike između

programskih jezika i načinu implementacije. Na kraju rada sažete su glavne razlike između

odabranih jezika, te je izveden zaključak.

3

2. Povijest objektno-orijentiranog programiranja

Objektno orijentirano programiranje je programska paradigma koja se zasniva na objektima i

pridruženim procedurama, odnosno metodama. Objekti su entiteti koji kombiniraju svojstva

procedura i podataka prilikom izvršavanja operacija, odnosno računanja [Stefik M, Daniel G,

1985]. Početak programiranja i programskih jezika započeo je 1950-ih godina sa proceduralnim i

strukturno-orijentiranim jezicima kao što su FORTRAN, COBOL i ALGOL. Programi napisani u

proceduralnim jezicima sadržavali su potprograme koji su se mogli izvršavati po želji pozivom iz

glavnog programa. Programeri koji su pisali programe u proceduralnim jezicima morali su sve

algoritme za računanje, sortiranje i ostale standardne procedure pisati u svakom programu

ispočetka, što je potaknulo razvoj funkcijskih programskih jezika. Funkcijski jezici imaju

ugrađene algoritme za standardne operacije, te se programi uglavnom sastoje od poziva

matematičkih algoritama i funkcija. Idući korak u razvoju programskih jezika bio je uvođenje

formalne logike. Logičko programiranje zadržava glavne značajke funkcijskog programiranja, ali

i uvodi nove koncepte koji omogućavaju definiranje činjenica i pravila o domeni problema, gdje

pravila ne moraju biti strogo definirana unutar programa, ali mogu biti izvedena iz činjenica

[Lovrenčić et al., 2009]. Na slici 2.1. prikazana je klasifikacija programskih jezika.

Slika 2.1. Klasifikacija programskih jezika

Izvor: Lovrenčić et al., 2009, str. 103

Prvi objektni jezik je SIMULA koji je nastao 1960-ih godina. Jezik SIMULA koristio se za

kreiranje simulacija. U to vrijeme, Alan Kay sa Sveučilišta u Utahu ima viziju o osobnom

računalu koje bi izvršavalo grafički-orijentirane aplikacije. On smatra kako bi takve aplikacije

4

mogao pisati bilo tko, a ne samo stručnjaci, upravo u jeziku SIMULA. Kay svoju viziju prodaje

tvrtki Xerox PARC, te ranih 1970-ih grupa stručnjaka u Xerox PARC-u na čelu s Alanom

Kayom razvija osobno računalo pod nazivom Dynabook. Razvija se i Smalltalk, odnosno prvi

objektno-orijentirani jezik razvijen upravo za programiranje na Dynabooku." Tvrtka Xerox

PARC prvi puta u povijesti koristi pojam “objektno-orijentirano programiranje” u opisu svog

programskog jezika Smalltalk. Taj pojam koristio se kako bi se opisao proces korištenja objekata

kao temelj za izračunavanje. Programski jezik Smalltalk razvijen je tako da bude dinamičan, tj.

objekti su se mogli kreirati, mijenjati i brisati, što je bilo drugačije od statičkih sustava koji su se

općenito koristili u to vrijeme. Ranih 1980-ih godina Bjarne Stroustrup integrira koncept

objektno-orijentiranog programiranja u jezik C što rezultira nastankom novog jezika pod

nazivom C++. Jezik C++ postaje prvi objektno-orijentirani komercijalni jezik koji i danas ima

široku primjenu. Ranih 1990-ih godina grupa stručnjaka u tvrtki Sun na čelu s Jamesom

Goslingom razvija jednostavniju verziju C++ pod nazivom Java. Java je isprva trebao biti

programski jezik za programiranje aplikacija za video na zahtjev (eng. Video on Demand

(VoD)). Projekt nije išao u pravom smjeru, te je grupa stručnjaka odlučila usredotočiti Javu na

tržište jezika za programiranje Internet aplikacija. To se pokazalo kao ispravna odluka, jer

širenjem i popularizacijom Interneta i programski jezik Java postaje sve popularniji [Huang,

2004]. Na slici 2.2. prikazan je povijesni razvoj objektno-orijentiranih programskih jezika.

Slika 2.2. Povijest objektno-orijentiranih programskih jezika (Smalltalk, C++, Java)

Izvor: Computer Science & Engineering, cs.washington.edu (2004)

Danas objektno orijentirani (OO) dizajn i objektno-orijentirano programiranje (OOP) postaje sve

popularnije, stoga je vrlo korisno poznavati i razumjeti OOP i glavne značajke OO jezika.

Razvijanje OO softvera je moguće u bilo kojemu jeziku više razine, poput C-a ili Pascala. Noviji

5

jezici poput C++, Ada i F90 (Fortran 90) imaju elemente i mogućnosti koje omogućuju prirodno

i praktično OOP [Akin, 2001]. Te mogućnosti su: enkapsulacija, nasljeđivanje i polimorfizam.

Kod OOP-a program se sastoji od objekata koji međusobno komuniciraju slanjem poruka. Svaki

objekt ima tip podataka, te zauzima mjesto u memoriji. Objekt je enkapsulacija podatka,

odnosno objekt ima identitet, tj. jedinstvenu referencu, stanje i ponašanje. Objekt je instanca

apstraktnog tipa podataka, a apstraktni tipovi podataka se implementiraju pomoću klasa.

“Enkapsulacija ili učahurivanje predstavlja ujedinjavanje svih atributa i metoda u cjelinu - klasu”

[Radošević, 2007, str. 114]. Pojedini autori enkapsulaciju definiraju malo drugačije;

“enkapsulacija je postupak skrivanja detalja implementacije klase od korisnika klase”

[Radošević, 2007, str. 115 citirano prema Mirković, 2005]. Drugo važno svojstvo, nasljeđivanje,

odnosi se na nasljeđivanje atributa i metoda iz osnovne klase na izvedene klase, pri čemu prava

pristupa naslijeđenim članovima klasa mogu i ne moraju biti ista kao u osnovnoj klasi

[Radošević, 2007, str. 132]. “Polimorfizam predstavlja mogućnost da se objekti iz izvedenih

klasa promatraju kao da su iz svojih osnovnih klasa, odnosno mogućnost da se objekti izvedenih

klasa dohvaćaju preko pokazivača iz osnovnih klasa. Pritom se, osim atributa, preko pokazivača

iz osnovnih klasa pristupa i metodama izvedenih klasa” [Radošević, 2007, str. 221].

6

3. Objektno-orijentirani programski jezici

U nastavku ovog rada opisani su i implementirani mehanizmi agregacije u različitim objektno-

orijentiranim programskim jezicima. U ovom poglavlju bit će riječi o programskim jezicima i

tehnologijama koje su se koristile prilikom implementacije mehanizama agregacije.

3.1 C++

Prema podacima koji se nalaze u članku A History Of C++: 1979-1991 [Stroustrup, 1996]

C++ je programski jezik opće namjene i srednje razine. On sadrži proceduralnu, funkcijsku,

objektno-orijentiranu i generičku programsku paradigmu. Programski jezik C++ razvio je Bjarne

Stroustrup početkom 1980-ih godina u laboratoriju telekomunikacijske tvrtke Bell Labs. Jezik je

dizajniran s fokusom prema sistemskom programiranju, ali se pokazalo da je efikasan i u razvoju

desktop aplikacija, servera, video igara, aplikacija koje zahtijevaju visoke performanse (npr.

telefonski preklopnik), itd. Razvoj C++ jezika započeo je kao nadogradnja na jezik C, te je

isprva nosio naziv “novi C” (eng. new C) zatim “C s klasama” (eng. C with classes), te je na

kraju nazvan C++ gdje “++” označava operator inkrementa u samom jeziku. Godine 1985.

izdano je prvo izdanje “The C++ Programming Language” knjige koja opisuje C++ programski

jezik koju je napisao autor programskog jezika, Bjarne Stroustrup. Tijekom narednih godina,

programski jezik C++ se razvijao i nadograđivao. Tako je 1989. godine izdana inačica C++ 2.0

koja donosi nove mogućnosti poput višestrukog nasljeđivanja, apstraktnih klasa, statičnih

članova klasa, itd. Na slici 3.1. prikazan je Turbo C++, razvojno okruženje za C++ razvijeno u

tvrtki Borland.

Slika 3.1. Turbo C++, Borlandov IDE za programski jezik C++

7

Izvor: Gensan Blog (2011)

Godine 2011. izdana je inačica C++11 koja donosi brojne nove mogućnosti i proširenja

standardnih biblioteka, a novi dodaci planirani su za 2014. i 2017. godinu. C++ je standardiziran

od strane Međunarodne organizacije za standardizaciju (eng. International Organization for

Standardization (ISO)). U tablici 3.1. prikazana je standardizacija jezika C++, od kojih je

ISO/IEC 14882:2011 (poznatiji kao C++11) posljednji odobren i izdan standard od strane ISO-a.

Tablica 3.1. Standardizacija programskog jezika C++

Godina C++ standard Neslužbeno ime

1998. ISO/IEC 14882:1998 C++98

2003. ISO/IEC 14882:2003 C++03

2007. ISO/IEC TR 19768:2007 C++TR1

2011. ISO/IEC 14882:2011 C++11

2014. N3690 (nedovršen koncept) C++14

Izvor: International Organization for Standardization (ISO), http://www.iso.org (2014)

3.1.1 Code::Blocks

Za implementaciju mehanizama agregacije u programskom jeziku C++ korišten je Code::Blocks

IDE. Integrirano razvojno okruženje (eng. Integrated development environment (IDE)) je softver

koji programeru pruža jednostavniji razvoj softvera. IDE se sastoji od uređivača teksta (eng.

editor), kompajlera (eng. compiler), odnosno interpretera, alata za automatsku izgradnju

programa (eng. build automation) i debuggera (eng. debugger). Code::Blocks je besplatni C,

C++ i Fortran IDE otvorenog koda (eng. open source) koji je vrlo prilagodljiv i proširiv.

Code::Blocks se može proširiti s priključcima (eng. plug-in) koji mogu donijeti razne dodatne

funkcionalnosti. Funkcionalnosti poput debuggiranja i kompajliranja dodane su kao priključci.

Za izradu programa u ovom radu korištena je inačica 13.12 s ugrađenim GCC (eng. GNU

Compiler Collection) kompajlerom. GCC je kompajler koji podržava razne jezike poput C, C++,

Fortran, Java, Ada, itd.

8

3.1.2 Programski primjer

Na slici 3.2. je prikazan primjer programa koji ispisuje poruku “Hello World!”. Program je

napisan u razvojnom okruženju Code::Blocks.

Slika 3.2. Hello World program napisan u jeziku C++ (Code::Blocks)

Na početku programa uključene su biblioteke iostream i cstdlib. Biblioteka iostream koristi se za

standardne ulazne i izlazne tokove, u ovom slučaju naredbu cout pomoću koje se ispisuje poruka

“Hello World!”. Biblioteka cstdlib koristi se za funkcije opće namjene kao što su dinamičko

upravljanje memorijom, generiranje nasumičnog broja, komunikaciju programa s okolinom,

pretraživanje, sortiranje, itd. U ovom primjeru se biblioteka cstdlib uključuje kako bi se mogla

izvršiti sistemska naredba system("pause"); koja zamrzava program sve dok korisnik ne pritisne

neku tipku za nastavak. Na početku programa se uključuje i imenski prostor (eng. namespace)

std. Svi entiteti (varijable, tipovi, konstante i funkcije) standardne C++ biblioteke su deklarirani

unutar imenskog prostora std. Uključivanje imenskog prostora std se koristi kako bi se

optimizirao kod, odnosno kako bi se uključila direktna vidljivost svih imena imenskog prostora

std u programskom kodu. Bez uključivanja imenskog prostora std u ovom primjeru bilo bi

potrebno dodati std:: ispred cout naredbe (std::cout). Glavni dio koda ovog programa, odnosno

ispis poruke izvršava se u funkciji main. Main je posebna funkcija u svim C++ programima.

Svaki program započinje izvršavanje s main funkcijom bez obzira gdje se ona nalazila u kodu

[Cplusplus, 2014].

9

3.2 C#

Prema podacima koji se nalaze u članku C#, CSC 415: Programming Languages [Yahl, 2012]

C# je objektno-orijentirani programski jezik koji sadrži proceduralnu, funkcijsku, deklarativnu,

generičku, objektno-orijentiranu i komponentno-orijentiranu programsku paradigmu. C# je

namijenjen da bude jednostavan, moderan i objektno-orijentiran jezik opće namjene. Razvijen je

2002. godine od grupe stručnjaka koje je vodio Anders Hejlsberg u tvrtki Microsoft. Ime C#,

odnosno “C sharp” inspirirano je povišenom muzičkom notom u C-duru koja podsjeća na četiri

spojena plusa i tako implicira da je jezik C# inkrement jezika C++. Programski jezik C# je

razvijan unutar .NET razvojnog okruženja, te je kasnije prihvaćen kao standard od strane Ecma

(ECMA-334) i ISO (ISO/IEC 23270:2006). .NET je Microsoftov okvir (eng. framework),

odnosno skup biblioteka koje pojednostavljuju razvoj aplikacija za Microsoftove tehnologije

poput Windowsa, Windows trgovine (eng. Windows Store), Windows pametnih telefona (eng.

Windows Phone), Windows Servera, itd. C# je jedan od programskih jezika koji su razvijeni za

zajedničku jezičnu infrastrukturu (eng. Common Language Infrastructure (CLI)). Osnovna

namjena zajedničke jezične infrastrukture (CLI) je izrada i izvršavanje distribuiranih komponenti

i servisa, što je postignuto omogućavanjem programa pisanih u različitim jezicima da djeluju

zajedno, sposobnošću programa da opišu sami sebe i pružanjem izvršnog okruženja koje

podržava više platformi [Mayo, 2002]. .NET arhitektura je Microsoftova implementacija CLI s

dodanim paketima za podršku korisničkih sučelja, podataka, XML, Web servisa i biblioteka

temeljnih klasa. .NET Framework paket za razvoj softvera isporučuje se s četiri programska

jezika, a to su C++, C#, Visual Basic i F#. Prva inačica jezika izdana je 2002. godine, dok je

posljednja inačica izdana 10 godina kasnije, odnosno 2012 godine. Microsoftovo razvojno

okruženje Visual Studio koristi se za razvoj .NET aplikacija. U tablici 3.2. prikazane su inačice

programskog jezika C#, pripadne inačice .NET Frameworka i Microsoftovog IDE-a Visual

Studija.

Tablica 3.2 Inačice C# programskog jezika i razvojnog okruženja Visual Studija

C# inačica Godina izdanja .NET Framework Visual Studio

C# 1.0 2002. .NET Framework 1.0 Visual Studio .NET 2002

C# 1.2 2003. .NET Framework 1.1 Visual Studio .NET 2003

C# 2.0 2005. .NET Framework 2.0 Visual Studio 2005

C# 3.0 2007. .NET Framework 3.0

.NET Framework 3.5

Visual Studio 2008

Visual Studio 2010

10



Visual Studio 2013

Izvor: C# in Depth, 2013

3.2.1 Microsoft Visual Studio 2012

Za implementaciju mehanizama agregacije u programskom jeziku C# korišten je Microsoftov

Visual Studio 2012. Visual Studio služi za razvoj aplikacija za Microsoft Windows platforme,

web stranice, web aplikacije i web servise. Visual Studio ima ugrađeni uređivač teksta koji

podržava IntelliSense i refaktoriranje koda. IntelliSense je Microsoftova implementacija

pametnog prijedloga koda koji prilikom pisanja koda u Visual Studiju na temelju par napisanih

slova ponuđuje odabir ključnih riječi, varijabli, konstanti ili ostalih literala koje započinju s

napisanim slovima. Na slici 3.3. prikazan je princip rada IntelliSense-a.

Slika 3.3. IntelliSense - pop-up prozor s ponuđenim funkcijama

Visual Studio podržava različite programske jezike, te omogućuje uređivaču teksta i debuggeru

da podržavaju gotovo bilo koji programski jezik. Ugrađeni jezici su C, C++, C++/CLI, Visual

Basic (VB.NET), C# i F#. Visual Studio podržava i druge jezike poput Pythona, Rubyja, itd. koji

11

se mogu instalirati kao priključci. Na slici 3.4. prikazan je izbornik na kojem su ponuđeni

predlošci projekata u instaliranim programskim jezicima u Visual Studiju 2012.

Slika 3.4. Visual Studio 2012 - kreiranje novog projekta (odabir predloška)

Visual Studio je Microsoftov komercijalni IDE. Postoji nekoliko paketa Visual Studija.

Najosnovniji i besplatni je Visual Studio Express Edition, dok su komercijalne verzije Ultimate,

Premium, Professional, Test Professional i Team Fundation Server. Prilikom implementacije

mehanizama agregacije u ovom radu korišten je Visual Studio 2012 Ultimate koji je preuzet s

MSDNAA repozitorija.


Na slici 3.7. prikazan je primjer programa koji ispisuje poruku “Hello World!”. Program je

napisan u Microsoft Visual Studiju 2012.

Slika 3.5. Hello World program napisan u jeziku C# (MS Visual Studio 2012)

12

Na početku programa uključena je biblioteka System, koja je jedna od osnovnih biblioteka.

Biblioteka System sadrži klasu Console koja se koristi za standardne ulazne i izlazne tokove,

odnosno funkcije WriteLine i ReadLine. Klasa Console sadrži funkcije za rad sa standardnim

ulaznim i izlaznim tokovima (eng. input/output streams) i tokovima grešaka (eng. error streams).

Funkcija WriteLine ispisuje poruku “Hello World!” na zaslon, dok funkcija ReadLine čita

znakove unesene s tipkovnice. Bez funkcije ReadLine program bi se odmah nakon ispisa poruke

zatvorio. Za razliku od C++, u C# je za program HelloWorld definiran imenski prostor

HelloWorld u kojemu se nalazi klasa Program i statička funkcija main bez povratnog tipa, dok

se u C++ koristila samo funkcija main tipa int koja ima imala na kraju povratnu vrijednost nula

(return 0;) koja označava kraj programa. [MSDN, 2014].

3.3 Java

Prema podacima koji se nalaze u knjizi JavaTech, An Introduction to Scientific and Technical

Computing with Java [Lindsey C et al., 2005] Java je konkurentni, objektno-orijentirani

programski jezik temeljen na klasama, koji sadrži strukturnu, funkcionalnu, konkurentnu,

objektno-orijentiranu, generičku i reflektivnu programsku paradigmu. Programski jezik Java

razvijan je sa sloganom “Napiši jednom, pokreni bilo gdje” (eng. Write once, run anywhere

(WORA)), što znači da se aplikacije napisane u Javi mogu pokretati na bilo kojoj platformi,

odnosno ne moraju se ponovno kompajlirati kako bi se pokretale na drugoj platformi. Aplikacije

napisane u Javi se kompajliraju u instrukcijski set Javine virtualne mašine (eng. Java Virtual

Machine (JVM)) koji se naziva bytecode koji se zatim može pokretati na bilo kojem JVM-u bez

obzira na operacijski sustav. Programski jezik Java razvio je tim stručnjaka na čelu se Jamesom

Goslingom u tvrtki Sun Microsystems 1995. godine. Jezik je isprva nosio naziv Oak (hrast) koji

je dobio po hrastu koji je stajao ispred prozora Goslingova ureda. Kasnije je jezik preimenovan u

Green, te je na kraju preimenovan u Java. Naziv Java dobio je po zrnima kave koja se proizvode

na Indonezijskom otoku Javi, a koju su kreatori Jave konzumirali u velikim količinama. Na slici

3.8. prikazan je logo programskog jezika Java. Tvrtka Sun je 2006. godine izdala Javu kao

besplatni softver otvorenog koda (eng. free and open source software) pod uvjetima GNU

General Public License (GNU GPL). Posljednja inačica Jave izdana je 2014. godine pod

nazivom Java SE 8 (Java Standard Edition 8). U tablici 3.3. prikazane su najznačajnije inačice

Jave i godine izdanja.

13

Tablica 3.3. Inačice programskog jezika Java

Naziv (inačica) Godina izdanja

JDK 1.0 (Java Development Kit) 1996.

JDK 1.1 (Java Development Kit) 1997.

J2SE 1.2 (Java 2 Platform SE) 1998.




Java SE 6 (Java Standard Edition) 2006.



Izvor: JavaTech, An Introduction to Scientific and Technical Computing with Java, 2005

14

3.3.1 NetBeans

Za implementaciju mehanizama agregacije u programskom jeziku Java korišten je NetBeans IDE

8.0. NetBeans je službeni IDE za razvoj aplikacija u programskoj jeziku Java. On sadrži

analizator (eng. analyzator) i pretvarač (eng. converter) koda pomoću kojih se lako nadograđuju

aplikacije tako da koriste nove jezične konstrukte dostupne u Javi 8. Osim Jave, NetBeans

podržava i druge jezike, poput PHP, C/C++ i HTML5. Na slici 3.6. prikazan je izbornik koji se

prikazuje prilikom odabira novog projekta, na kojem su prikazani programski jezici dostupni

unutar NetBeans IDE-a.

Slika 3.6. NetBeans - kreiranje novog projekta (odabir projekta)

NetBeans uređivač teksta automatski radi uvlake, generira odgovarajuće zagrade, te označava

izvorni kod sintetički i semantički. Također, sadrži predloške koda, pruža savjete za kodiranje, te

sadrži alate za refaktoriranje koda. NetBeans IDE olakšava pregled podataka i projekata na način

da pruža više pogleda [NetBeans, 2014]. Na slici 3.7. prikazan je jednostavan i djelotvoran način

na koji se mogu pregledavati i upravljati projektima.

15

Slika 3.7. NetBeans - pregled i upravljanje projektima

Izvor: NetBeans (2014)


Na slici 3.8. prikazan je primjer Java programa koji ispisuje poruku “Hello World!”. Program je

napisan u NetBeans IDE 8.

Slika 3.8. Hello World program napisan u jeziku Java (NetBeans IDE 8)

16

Na početku programa definiran je paket helloworld. Paketi se u Javi koriste kako bi se povezane

klase, sučelja, enumeracije i anotacije spremile u isti imenski prostor. Enumeracije i anotacije su

posebne vrste klasa i sučelja. Nakon kreiranja paketa, kreira se javna klasa HelloWorld u kojoj se

nalazi funkcija main. Unutar funkcije main napisana je samo jedna linija koja poziva metodu za

ispis poruke na zaslon. Za ispis poruke koristi se klasa System koja sadrži funkcije i metode za

rad sa standardnim ulaznim i izlaznim tokovima, te tokovima grešaka.

3.4 Python

Prema podacima koji se nalaze u službenoj dokumentaciji programskog jezika Python [Python

Docs, 2014a], Python je programski jezik opće namjene i visoke razine. On sadrži proceduralnu,

funkcijsku, reflektivnu, imperativnu i objektno-orijentiranu programsku paradigmu. Guido van

Rossum započeo je razvijati Python pred kraj 1980-ih godina u tvrtki Centrum Wiskunde &

Informatica (CWI), a prva inačica izdana je 1991. godine. Jezik je nazvan po britanskoj grupi

komičara Monty Python. Programski jezik Python razvijan je s ciljem da bude jednostavan za

čitanje i razumijevanje. Njegova sintaksa omogućuje programeru da složeniji program napiše u

manje linija koda nego što bi isti napisao u nekom drugom jeziku kao što je C. Python podržava

dinamične tipove podataka i sustava, te sadrži automatski sustav upravljanja memorijom. Jedna

od najznačajnijih obilježja Pythona je mogućnost dinamičkog povezivanja imena (eng. dynamic

name resolution), odnosno mogućnost povezivanja imena metode i varijabli prilikom izvođenja

programa. Python koristi uvlake umjesto vitičastih zagradi ili ključnih riječi kako bi razdvojio

programske blokove. To svojstvo naziva se off-side rule. Na slici 3.9. prikazan je način

odvajanja programskim blokova korištenjem uvlaka.

Slika 3.9. Python - odvajanje programskih blokova korištenjem uvlaka

Python je razvijan pod licencom otvorenog koda što znači da je program besplatan, te se može

koristiti i u komercijalne svrhe. Licenca programskog jezika Python administrirana je od strane

Python Software Foundation. Zadnje stabilne inačice jezika su Python 3.4.1 i Python 2.7.8.

17

Inačica 2.x sadrži izvornu sintaksu, dok inačica 3.x predstavlja budućnost jezika. Posljednja

velika nadogradnja za inačicu 2.x izašla je 2010. godine. Python 3.x je pod aktivnim razvojem i

u zadnjih nekoliko godina izdano je nekoliko stabilnih inačica, točnije inačica 3.3 (2012. godine)

i 3.4 (2014. godine) [Python Wiki, 2014].

3.4.1 IDLE (Python GUI)

Za implementaciju mehanizama agregacije u programskom jeziku Python korišten je IDLE

(Python GUI). IDLE (Integrated DeveLopment Environment) je razvojno okruženje za

programski jezik Python koje dolazi u paketu s jezikom od inačice 1.5.2b1. Sam IDLE napisan je

u programskom jeziku Python i Tkinter GUI toolkitu. IDLE je poprilično jednostavan IDE koji je

prilagođen za početnike i za edukacijske svrhe. Neke od glavnih značajki IDLE-a su uređivač

teksta koji ima mogućnost pokretanja u više prozora, označavanje sintakse (eng. syntax

highlight), automatska dopuna (eng. autocompletion), pametno uvlačenje koda (eng. smart

indent), itd. IDLE ima i integrirani debugger [Python Docs, 2014b].


Na slici 3.10. prikazan je primjer Python programa koji ispisuje poruku “Hello World!”. Program

je napisan u IDLE-u.

Slika 3.10. Hello World program napisan u jeziku Python (IDLE Python GUI)

Za ispis poruke “Hello World!” u programskom jeziku Python dovoljna je samo jedna linija

koda, što govori koliko je jezik jednostavan i blizak govornom jeziku. Pisanje programa u

programskom jeziku Python toliko je jednostavno da je nazvano programiranje brzinom

18

razmišljanja. Programi napisani u Pythonu kraći su i pišu se za manje vremena nego programi

napisani u mnogim drugim jezicima [Dawson, 2010].

3.5 Delphi

Delphi je objektno-orijentirani programski jezik koji sadrži imperativnu, strukturnu, objektno-

orijentiranu, funkcionalnu, komponentnu i generičku programsku paradigmu. Programski jezik

Delphi se razvio iz objektnog Pascala (eng. Object Pascal). Programski jezik Pascal se prvi put

pojavio 1970. godine, a dizajnirao ga je Niklaus Wirth. Sredinom 1980-ih godina u tvrtki Apple

razvija se Object Pascal, odnosno ekstenzija za programski jezik Pascal, koja je razvijena od

strane stručnjaka koje je predvodio Larry Tesler u savjetovanju s Niklausom Wirthom. Appleov

Object Pascal se koristio na računalu Lisa. 1986. godine u tvrtki Borland razvijena je slična

ekstenzija za Turbo Pascal koja je nosila isti naziv kao i Appleova ekstenzija, Object Pascal.

Prva inačica Borlandovog Object Pascala pokretana je na Macintosh računalima, a 1989. godine

izdana je i ekstenzija za Turbo Pascal 5.5 koji se pokretao na DOS računalima. Godine 1994.

tvrtka Borland odlučila se usredotočiti na Windows platformu, te se tako razvio nasljednik Turbo

Pascala nazvan Delphi, koji je donio novi set ekstenzija iz kojih je nastao i sam programski jezik

Delphi. Prva inačica Delphi 1.0 službeno je objavljenja 1995. godine, a razvio ju je Anders

Hejlsberg. 2008. godine tvrtka Embarcadero Technologies kupuje Delphi, te razvija komercijalni

Delphi IDE za Windows i Max OS X platforme [Delphi Wiki, 2014].

3.5.1 Embarcadero Delphi XE7

Za implementaciju mehanizama agregacije u programskom jeziku Delphi korišten je

Embarcadero Delphi XE7. Embarcadero Delphi je integrirano razvojno okruženje za desktop,

web, mobilne i konzolne aplikacije. Delphijev kompajler koristi vlastiti dijalekt Object Pascala

koji generira kod za 32 i 64 bitne Windowse, te 32 bitni Mac OS X, iOS i Android. Prva inačica

Embarcadero Delphija pojavila se 2009. godine pod nazivom Embarcadero Delphi 2009.

Tijekom narednih godina IDE se razvijao, te je tako izašlo nekoliko inačica od kojih se

posljednja, Embarcadero Delphi XE7, na tržištu pojavila 2014. godine. Embarcadero Delphi

XE7 omogućuje Delphi i C++ programerima da prošire postojeće Windows aplikacije i kreiraju

nove, moderne aplikacije koje povezuju desktop računala i mobilne uređaje sa servisima u

oblacima (eng. cloud services), bazama podataka i s aplikacijskim programskim sučeljima (eng.

application programming interface (API)). Embarcadero Delphi XE7 osim Delphija ima i

podršku za C++ programski jezik. Pošto je Embarcadero Delphi komercijalni IDE, u ovom radu

korištena je probna inačica (eng. trial) čija licenca ističe nakon 30 dana.

19


Na slici 3.11. prikazan je primjer programa koji ispisuje poruku “Hello World!”. Program je

napisan u Embarcadero Delphi XE7 razvojnom okruženju.

Slika 3.11. Hello World program napisan u jeziku Delphi (Embarcadero Delphi XE7)

Na početku programa uključuje se biblioteka System.SysUtils. Biblioteka System sadrži sve

Delphi run-time (RTL) jedinice, klase, funkcije, tipove podataka, varijable i konstante.

Programski blok u kojem se ispisuje poruka “Hello World!” započinje s riječi begin, a završava s

end.

20

4. Mehanizmi agregacije

Mehanizmi agregacije, odnosno složeni tipovi podataka imaju osnovno svojstvo da su logički

djeljivi, odnosno formiraju se od jednostavnijih tipova i složenih tipova niže razine [Radošević,

2007]. Među mehanizme agregacije ubrajamo: polja, znakovne nizove, strukture (zapise), unije i

klase. U ovom poglavlju implementirani su mehanizmi agregacije u ranije spomenutim

programskim jezicima.

4.1 Polje

“Polje je mehanizam agregacije kojim se od jednostavnih tipova podataka tvori složeniji tip

podataka. Polje čini niz varijabli istog tipa koje su imenovane zajedničkim identifikatorom i

nalaze se na uzastopnim memorijskim lokacijama. Svaka varijabla u polju naziva se element

polja.” [Lovrenčić, 2010]. Svaki element u polju ima svoj indeks preko kojeg mu se pristupa.

Pošto se varijable u polju nalaze na uzastopnim memorijskim lokacijama, dovoljno je pamtiti

samo memorijsku lokaciju nultog elementa, jer se lokacije ostalih elemenata mogu izračunati na

sljedeći način:

lokacija 0-tog elementa + veličina elementa × indeks.

Na slici 4.1. prikazana je struktura polja koje ima 10 elemenata, gdje se indeksi polja kreću od 0

do 9.

Slika 4.1. Struktura polja koje sadrži 10 elemenata

Izvor: National Technical University of Athens, www.math.ntua.gr (2014)

Polje može imati više dimenzija. Dvodimenzionalno polje je polje kojem je svaki element novo

polje. U nastavku slijedi prikaz implementacije polja u različitim objektno-orijentiranim


4.1.1 C++

U programskom jeziku C++ po načinu alokacije razlikujemo statička i dinamička polja. Statičko

polje alocira se prije početka izvršavanja programa na sljedeći način:

21

int polje[10]; //Polje tipa integer koji sadrži 10 elemenata.

Statičko polja je zadano konstantom i ne mijenja se do kraja izvršavanja programa. Dealokacija

statičkog polja nije moguća prije kraja izvođenja programa. Dinamičko polje alocira se

dinamički u radnoj memoriji na sljedeći način:

int *x = new int[10]; // Polje tipa integer koji sadrži 10 elemenata.

Za razliku od statičkog polja, dinamički alocirano polje može se dealocirati tijekom izvođenja

programa na sljedeći način:

delete [] x; //Dealokacija polja x.

Statičko polje koristi implicitni pokazivač, što znači da se elementi polja dohvaćaju preko naziva

polja u kojemu je spremljena memorijska adresa nultog elementa. Dinamičko polje koristi

eksplicitni pokazivač koji je alociran u radnoj memoriji [Radošević, 2007]. Na slici 4.2. prikazan

je primjer statičkog polja koje se alocira s n elemenata, te se zatim polje popunjava s cijelim

brojevima.

Slika 4.2. Primjer polja u programskom jeziku C++

4.1.2 C#

U programskom jeziku C# polja se alociraju dinamički, na sljedeći način:

int[] polje = new int[10]; //Polje tipa integer od 10 elemenata.

Kao i u programskom jeziku C++, polja se mogu deklarirati i bez inicijalizacije, ali se moraju

inicijalizirati prije upotrebe. Na slici 4.3. prikazan je isječak programa u kojem se deklarira i

inicijalizira polje od n elemenata, te se nakon toga polje puni cijelim brojevima.

Slika 4.3. Primjer polja u programskom jeziku C#

22

4.1.3 Java

U programskom jeziku Java polja se deklariraju i alociraju dinamički, na isti način kao i u

programskom jeziku C#. Na slici 4.4. prikazan je program u kojem se deklarira i inicijalizira

polje od n elemenata, te se nakon toga u polje unose cijeli brojevi. Nakon unosa polje se sortira

uzlazno, te se ispisuje.

Slika 4.4. Primjer polja u programskom jeziku Java

U primjeru je napisan algoritam za sortiranje. U programskom jeziku Java postoji funkcija

java.util.Arrays.sort(int[]) pomoću koje se također može sortirati polje, bez pisanja algoritma.

23

4.1.4 Python

U programskom jeziku Python polja se deklariraju na malo drugačiji način nego u do sada

opisanim jezicima. Polje od n elemenata deklarira se na sljedeći način:

polje = [0 for i in xrange(n)] //Deklaracija polja od n elemenata.

Unutar uglatih zagrada piše se for petlja koja određuje broj elemenata u polju. U programskom

jeziku Python se prilikom deklariranja varijabli, polja i drugih podataka ne mora navoditi tip

podataka, već se tip određuje prilikom unosa vrijednosti. Polje se prilikom deklariranja može

popuniti s brojevima na sljedeći način:

polje = [1,2,3,4,5] //Deklaracija polja od 5 elemenata: 1,2,3,4,5.

Na ovaj način definirano je polje koje sadrži pet elemenata, odnosno prirodne brojeve 1,2,3,4 i 5.

Elementi se nalaze na indeksima 0,1,2,3 i 4, tj. na lokaciji polje[0] nalazi se broj 1, na lokaciji

polje[1] broj 2, itd. Postoji još jedan način definiranja polja, a to je korištenjem klase array,

odnosno instanciranjem objekta klase array, što se vrši na sljedeći način:

class array.array (typecode[, initializer])

Na slici 4.5. prikazan je isti program koji je ranije napisan u programskom jeziku Java.

Slika 4.5. Primjer polja u programskom jeziku Python

U programskom jeziku Python također postoji ugrađena funkcija za sortiranje polja koja se

naziva sorted(), ali u ovom primjeru je napisan algoritam sortiranja umetanjem.

24

4.1.5 Delphi

U programskom jeziku Delphi polja se mogu alocirati statički i dinamički. Polje od 10 elemenata

se statički alocira na sljedeći način:

polje : Array[0..10] of Integer;

//Polje tipa integer koje sadrži 10 elemenata.

Polje se alocira dinamički na sljedeći način:

polje : Array of Integer; //Dinamička alokacija polja

SetLength (polje, 10); //Postavljanje veličine polja

U programskom jeziku Delphi varijable i polja se alociraju unutar bloka var. Program započinje

s izvršavanjem koda koji se nalazi unutar glavnog begin ... end; bloka koji je sličan main funkciji

u jeziku C++. Ukoliko se polje alocira dinamički, funkcija SetLenght piše se unutar glavnog

begin ... end; bloka. Na slici 4.6. prikazan je isječak programa napisanog u Delphiju na kojem je

prikazana statička deklaracija polja od 100 elemenata.

Slika 4.6. Primjer statičkog polja u programskom jeziku Delphi

4.2 Znakovni niz

Znakovni nizovi su jednodimenzionalna znakovna polja koje služe za pohranjivanje tekstova.

Znakovni nizovi se koriste za spremanje i ispisivanje različitih poruka na zaslon. Na slici 4.7.

prikazana je struktura znakovnog niza. Na kraju znakovnog niza obično se nalazi NULL ili '\0'

koji označava kraj niza.

Slika 4.7. Struktura znakovnog niza

Izvor: Saint Vincent College, cis.stvincent.edu (2013)

25

U nastavku slijedi prikaz implementacije znakovnog niza u različitim objektno-orijentiranim


4.2.1 C++

Znakovni niz u programskom jeziku C++ je polje tipa char. Znakovni nizovi se inicijaliziraju na

sljedeći način:

char znakovni_niz[10]; //Inicijalizacija znakovnog niza

char znakovni_niz2[] = “Znakovni niz”; //Inicijalizacija i deklaracija

Na slici 4.8. prikazan je isječak programa napisanog u programskom jeziku C++ na kojem je

prikazana primjena znakovnog niza.

Slika 4.8. Primjer znakovnog niza u programskom jeziku C++

Naredba cin.getline(polje, 1000) koristi se za spremanje znakovnog niza unesenog putem

tipkovnice u polje koje može imati maksimalno 999 znakova, jedno mjesto u nizu čuva se za

NULL znak ('\0') koji označava kraj niza. Nakon što se niz spremi u polje velika slova u nizu se

pretvaraju u mala, a mala slova u velika na način da se mijenja njihov ASCII kod dodavanjem ili

oduzimanjem broja 32.

4.2.2 C#

Znakovni niz u programskom jeziku C# može se zapisati u polje tipa char ili u poseban tip

podataka string. Znakovni niz definira se na sljedeći način:

char[] polje = new char[10]; //Inicijalizacija znakovnog niza,

//polje tipa char

26

string niz = string.Empty; //Inicijalizacija znakovnog niza tipa string

Na slici 4.9. prikazan je isječak programa napisanog u programskom jeziku C# na kojem je

prikazana primjena znakovnog niza.

Slika 4.9. Primjer znakovnog niza u programskom jeziku C#

Prilikom unosa teksta, znakovni niz je spremljen u string, te je zatim prebačen u polje tipa char

pomoću petlje foreach. Nakon toga je svako malo slovo u polju tipa char pretvoreno u veliko, a

svako veliko slovo pretvoreno u malo, na način da je oduzet ili dodan broj 32 (promjena ASCII

koda slova). U programskom jeziku C# postoje funkcije ToUpper() i ToLower() pomoću kojih se

mogu slova u stringu promijeniti iz malih u velika i obrnuto.

4.2.3 Java

Znakovni niz u programskom jeziku Java može se zapisati u polje tipa char ili string, slično kao

i u jeziku C#. Na slici 4.10. prikazan je isječak koda koji prikazuje način uporabe polja tipa char

i stringa u programskom jeziku Java.

27

Slika 4.10. Primjer znakovnog niza u programskom jeziku Java

Prilikom inicijalizacije polja polje[] tipa char iza znaka jednakosti nije potrebno pisati operator

new iz razloga što se polje odmah deklarira, odnosno puni se znakovnim nizom koji je upisan u

varijablu tekst koja je tipa string.

4.2.4 Python

Znakovni niz u programskom jeziku Python može se definirati na način da se inicijalizira objekt

klase array s kodom 'c' koji označava polje tipa char ili da se običnoj varijabli pridruži znakovni

niz. Na slici 4.11. prikazana je uporaba klase array za kreiranje polje tipa char, te uporaba

obične varijable za spremanje znakovnog niza.

Slika 4.11. Python - korištenje klase array i varijable za spremanje znakovnih nizova

Na slici 4.12. prikazan je programski primjer koji velika slova pretvara u mala, a mala u velika.

Program je riješen na sličan način kao i u drugim jezicima, odnosno tako da mijenja ASCII kod

slova dodavanjem ili oduzimanjem broja 32.

28

Slika 4.12. Primjer znakovnog niza u programskom jeziku Python

4.2.5 Delphi

Znakovni niz u programskom jeziku Delphi može se zapisati u polje tipa char ili string, slično

kao i u jezicima C# i Java. Na slici 4.13. prikazan je isječak koda koji prikazuje način uporabe

polja tipa char i varijable tipa string u programskom jeziku Delphi. Nakon unosa teksta u polje,

velika i mala slova zamjenjuju se na način da se mijenja njihov ASCII kod.

29

Slika 4.13. Primjer znakovnog niza u programskom jeziku Delphi

4.3 Struktura

“Strukture su složeni tipovi podataka koji uključuju više elemenata različitog naziva i različitog

tipa” [Radošević, 2007, str. 10]. Elementi strukture nalaze se u istom bloku unutar memorije i

pristupa im se putem jednog pokazivača, odnosno identifikatora. Na slici 4.13. prikazana je

jednostavna struktura koja ima dva elementa, ime (eng. name) i dužinu (eng. lenght) pjesme,

identifikator strukture je polje Title.

30

Slika 4.14. Primjer strukture

Izvor: The Tenouk, www.tenouk.com (C Structures)

4.3.1 C++

Slično poljima, i strukture se mogu alocirati statički i dinamički na sljedeći način:

struct tstruktura {

int broj_strukture;

};

tstruktura st1; //Statička alokacija strukture.

tstruktura *st2 = new tstruktura;//Dinamička alokacija strukture.

Pristup elementima statičkih struktura moguće je pomoću operatora točke, '.'.

st1.broj_strukture = 1;

Elementima dinamičkih struktura pristupa se pomoću operatora '->' [Radošević, 2007].

st2->broj_strukture = 2;

Na slici 4.15. prikazan je isječak programa napisanog u programskom jeziku C++ koji prikazuje

način na koji se definira i alocira struktura tstudent.

Slika 4.15. Primjer strukture u programskom jeziku C++

31

4.3.2 C#

U programskom jeziku C# strukture se mogu alocirati statički i dinamički na sličan način kao i u

programskom jeziku C++, a samo definiranje strukture je identično. Na slici 4.15. prikazan je

isječak programa u kojem se definira i alocira struktura.

Slika 4.16. Primjer strukture u programskom jeziku C#

4.3.3 Java

U Javi ne postoji struktura, ali se zato može definirati klasa koja će zamijeniti ulogu strukture.

Na slici 4.17. prikazan je isječak programa napisanog u Javi u kojemu se klasa upotrebljava kao

struktura u programskom jeziku C++ ili C#.

Slika 4.17. Korištenje klase kao zamijene za strukturu u programskom jeziku Java

32

4.3.4 Python

Programski jezik Python nema strukture, ali zato ima kolekciju namedtuple koja se ponašao vrlo

slično kao struktura u programskom jeziku C++, odnosno C#. Za korištenje kolekcije

namedtuple potrebno je napisati sljedeću liniju koda:

from collections import namedtuple

Kolekcija namedtuple se koristi na sljedeći način:

kolekcija = namedtuple("kolekcija", "varijabla1 varijabla2")

Funkcija namedtuple vraća novu podklasu klase tuple koja ima naziv kolekcija i dvije varijable

(varijabla1 i varijabla2). Nova podklasa se koristi kako bi se kreirali objekti koji imaju zadane

atribute kojima se može pristupati, slično kao i kod strukture u programskom jeziku C++

[Python Docs, 2014c]. Na slici 4.18. prikazan je primjer napisan u programskom jeziku Python

koji koristi kolekciju namedtuple za grupiranje različitih tipova podataka.

Slika 4.18. Korištenje kolekcije namedtuple u programskom jeziku Python

33

4.3.5 Delphi

U programskom jeziku Delphi za definiranje strukture koristi se ključna riječ Record umjesto

struct u programskim jezicima C++ i C#. U Delphiju se struktura definira na sljedeći način:

type

tstruktura = Record

varijabla1: Integer;

varijabla2: string;

end;

Na slici 4.19. prikazan je isječak programa napisanog u Delphiju koja prikazuje način na koji se

upotrebljava struktura Record.

Slika 4.19. Korištenje strukture Record u programskom jeziku Delphi

4.4 Klasa

“Pojmovi klase i objekta temeljni su u objektnom programiranju. Klasa predstavlja tip, a objekt

instancu tipa. Za razliku od strukture iz jezika C (deklaracija struct), klasa osim podataka

definira i procese obrade podataka. Klasa definira svoje članove. Članovi klase su atributi

(podatkovni članovi) i metode (funkcijski članovi). Atributi se odnose na podatke, slično

34

članovima strukture iz jezika C. Metode predstavljaju funkcije koje pripadaju klasi. Deklaracija

class uvodi specifikatore pristupa koji određuju prava pristupa pojedinim članovima klasa.

public - javni pristup; takvi članovi dostupni su iz svih dijelova programa

protected - zaštićeni pristup; pravo pristupa iz osnovne klase i klasa koje je nasljeđuju

private - privatni pristup; može im se pristupiti samo iz klase gdje su deklarirani

Zaštićeni pristup (protected) članovima klase znači pravo pristupa članovima klase iz metoda

klase gdje su definirani i iz metoda podređenih klasa.” [Radošević, 2007, str. 111-12].

4.4.1 C++

Na slici 4.20. prikazan je isječak koda C++ programa na kojem je definirana osnovna klasa

cracunalo i izvedena klasa cstolno_racunalo.

Slika 4.20. Korištenje klasa u programskom jeziku C++

Klasa cracunalo ima javne atribute proizvodac, godina_proizvodnje, cijena i javnu metodu

ispis() koji su naslijeđeni i u izvedenoj klasi cstolno_računalo. Izvedena klasa cstolno_racunalo

ima javne atribute kuciste i napajanje, te javnu metodu ispis() pomoću koje se ispisuju svi

njezini atributi. Deklaracija objekata klasa cracunalo i cstolno_racunalo izvodi na sljedeći način:

cracunalo *racunalo = new cracunalo; //Deklaracija objekta racunalo

35

cstolno_racunalo *stolno_racunalo = new cstolno_racunalo[N];

Polje stolno_racunalo sadrži N objekata klase cstolno_racunalo.

4.4.2 C#

Klase u programskom jeziku C# definiraju se i koriste na sličan način kao i u programskom

jeziku C++. Na slici 4.21. prikazan je isječak koda C# programa na kojem je definirana osnovna

klasa cracunalo i izvedena klasa cstolno_racunalo slično kao i u programskom jeziku C++.

Slika 4.21. Korištenje klasa u programskom jeziku C#

Deklaracija objekata klasa cracunalo i cstolno_racunalo izvodi na sljedeći način:

cracunalo racunalo = new cracunalo(); //Deklaracija objekta racunalo

cstolno_racunalo[] stolno_racunalo = new cstolno_racunalo[N];

Polje stolno_racunalo sadrži N objekata klase cstolno_racunalo.

4.4.3 Java

Klase u programskom jeziku Java definiraju se i koriste na sličan način kao i u programskim

jezicima C++ i C#. Najveća razlika je što se prilikom nasljeđivanja klase umjesto operatora ':'

piše ključna riječ extends. Na slici 4.22. prikazan je isječak koda Java programa na kojem je

definirana osnovna klasa cracunalo i izvedena klasa cstolno_racunalo.

36

Slika 4.22. Korištenje klasa u programskom jeziku Java

Na slici 4.23. prikazan je način deklariranja klasa cracunalo i cstolno_racunalo, koji je identičan

načinu deklariranju klasa u jeziku C#.

Slika 4.23. Deklariranje klasa Javi

4.4.4 Python

U programskom jeziku Python svi članovi klase su javni, te se ispred atributa i metoda ne mora

pisati ključna riječ public. Funkcija, metoda ili varijabla definirana unutar klase s prefiksom '__'

(npr. __var) tretira se kao privatni član klase. Prefiks '__' se koristi kako bi se izbjegli incidenti,

odnosno podudaranja imena s imenima naslijeđenih klasa [Python Docs, 2014d]. Prilikom

definiranja izvedene klase naziv klase iz koje se atributi i metode nasljeđuju piše se u oblim

zagradama (npr. class izvedena_klasa (osnovna_klasa):). Na slici 4.24. prikazan je isječak koda

Python programa na kojem je definirana osnovna klasa cracunalo i izvedena klasa

cstolno_racunalo.

37

Slika 4.24. Korištenje klasa u programskom jeziku Python

Deklaracija N objekata klase cstolno_racunalo izvodi na sljedeći način:

stolno_racunalo = [0 for i in xrange(N)]

for i in range(N):

stolno_racunalo[i] =

cstolno_racunalo(raw_input("\nProizvodac racunala: "))

Unutar klase cstolno_racunalo definiran je konstruktor, te se prilikom deklaracije objekta klase

cstolno_racunalo prosljeđuje naziv proizvođača računala koji se u konstruktoru sprema u

varijablu proizvodac.

4.4.5 Delphi

U programskom jeziku Delphi prvo se definiraju klase s atributima i nazivima procedura,

funkcija i konstruktora, te se nakon toga pišu funkcionalnosti procedura, funkcija i konstruktora.

Prilikom definiranja izvedene klase naziv klase iz koje se atributi i metode nasljeđuju piše se na

sljedeći način:

izvedena_klasa = class (osnovna_klasa)

Deklaracija klase piše se unutar var bloka na sljedeći način:

var: cklasa1; //Deklaracija objekta var klase cklasa1.

polje: array[0..N] of cklasa2; //Deklaracija N objekata polje

//klase cklasa2.

Na slici 4.25. prikazan je isječak koda Delphi programa na kojem je definirana osnovna klasa

cracunalo i izvedena klasa cstolno_racunalo.

38

Slika 4.25. Korištenje klasa u programskom jeziku Delphi

4.5 Unija (C++)

“U programskom jeziku C++ postoji mehanizam agregacije koji omogućuje da se alternativni

podaci čuvaju u istom memorijskom prostoru. Taj se mehanizam agregacije naziva unija.

Deklaracija unije u potpunosti je jednaka po sintaksi i svojstvima deklaraciji strukture, osim u

ključnoj riječi union koja se koristi umjesto ključne riječi struct” [Lovrenčić, 2010]. Na slici

4.26. prikazan je primjer korištena unije.

Slika 4.26. Definiranje unije i struktura u jeziku C++

Struktura racunalo se pomoću unije pod proširuje sa strukturama stolno_racunalo i

prijenosno_racunalo. Unutar strukture racunala definira se polje i broj računala koja će biti

39

unesena. Prilikom unošenja podataka o računalu korisnik bira želi li unijeti stolno ili prijenosno

računalo, te se prema tome dodatni podaci spremaju u strukturu stolno_racunalo ili

prijenosno_racunalo, dok su osnovni podaci spremljeni u strukturu racunalo.

40

5. Zaključak

Programiranje je umijeće pisanja računalnih programa. U povijesti se pojam “objektno-

orijentirano programiranje” prvi puta pojavljuje u dokumentaciji jezika Smalltalk kojeg je razvila

grupa stručnjaka na čelu s Alanom Kayom u tvrtki Xerox PARC. Tijekom narednih godina

razvijaju se programski jezici poput Pascala i C-a koji su utjecali na daljnji razvoj objektno-

orijentiranih jezika više razine. U današnje vrijeme objektno-orijentirano programiranje sve je

popularnije, stoga je vrlo korisno poznavati i razumijevati objektno-orijentirano programiranje i

glavne značajke objektno-orijentiranih jezika. Razvijanje objektno-orijentiranih softvera moguće

je u bilo kojem jeziku više razine, poput jezika C++, C#, Java, Python, Delphi, i dr. Za

razumijevanje složenijih računalnih programa bitno je poznavanje mehanizama agregacije koji

se formiraju od jednostavnijih tipova podataka i složenih tipova niže razine. Mehanizmi

agregacije su polja, znakovni nizovi, strukture, unije i klase.

Od navedenih mehanizama agregacije jedino programski jezik C++ sadrži sve mehanizme. Polje

je mehanizam agregacije koji se najčešće koristi. Polje čini niz varijabli istog tipa koje se nalaze

na uzastopnim memorijskim lokacijama, te se u svim navedenim jezicima definira i koristi na

sličan način. Znakovni nizovi se mogu definirati kao polje tipa char ili kao poseban tip podatka

string. U jezicima više razine, poput C#, Java i Python češće se koristi varijabla tipa string za

spremanje znakovnih nizova iz razloga što je string objekt, a jezici više razine imaju ugrađene

funkcije za rad s takvim objektima (npr. funkcija ToUpper() u jeziku C# pretvara sva mala slova

u velika). Struktura je mehanizam agregacije koja je iz programskoj jezika C naslijeđena u C++ i

C#. U jeziku C++ i C# struktura se definira i koristi na gotovo identičan način. Glavna razlika je

u alokaciji varijable koja je tipa strukture. Programski jezik Delphi također sadrži strukturu, ali

se umjesto ključne riječi struct za definiranje strukture koristi riječ Record. Jezici Java i Python

ne sadrže strukturu, ali se ona može na jednostavan način implementirati pomoću klase ili

pomoću dodatnih biblioteka koji dodaju sličan mehanizam strukturi (namedtuple u jeziku

Python). Klase i objekti su osnovne karakteristike svih objektno-orijentiranih jezika, te se u

navedenim jezicima definiraju i koriste na sličan način. U programskom jeziku C++ postoji još

jedan mehanizam agregacije koji je naslijeđen iz strukturnog programiranja, odnosno iz jezika C.

Taj mehanizam naziva se unija, te on omogućuje da se alternativni podaci čuvaju u istom

memorijskom prostoru, što danas više nije toliko bitno iz razloga što računala ima znatno više

memorije.

Programski jezik C++ dobar je izbor jezika za početnike iz razloga što nasljeđuje C jezik i

njegovu proceduralnu i strukturnu paradigmu, te još k tome sadrži objektno-orijentiranu,

funkcionalnu i generičku paradigmu. Nakon savladavanja jezika C++ prelazak na druge

41

objektno-orijentirane jezike ne bih trebao biti problematičan, pogotovo na jezike više razine

poput Pythona čija je sintaksa poprilično jednostavna i lako razumljiva.

42

POPIS SLIKA

Slika 2.1. Klasifikacija programskih jezika .................................................................................... 3 Slika 2.2. Povijest objektno-orijentiranih programskih jezika (Smalltalk, C++, Java) ................... 4 Slika 3.1. Turbo C++, Borlandov IDE za programski jezik C++ ................................................... 6

Slika 3.2. Hello World program napisan u jeziku C++ (Code::Blocks) ......................................... 8 Slika 3.3. IntelliSense - pop-up prozor s ponuđenim funkcijama ................................................. 10 Slika 3.4. Visual Studio 2012 - kreiranje novog projekta (odabir predloška) ............................... 11 Slika 3.5. Hello World program napisan u jeziku C# (MS Visual Studio 2012) .......................... 11 Slika 3.6. NetBeans - kreiranje novog projekta (odabir projekta) ................................................ 14

Slika 3.7. NetBeans - pregled i upravljanje projektima ................................................................ 15 Slika 3.8. Hello World program napisan u jeziku Java (NetBeans IDE 8) ................................... 15 Slika 3.9. Python - odvajanje programskih blokova korištenjem uvlaka ...................................... 16 Slika 3.10. Hello World program napisan u jeziku Python (IDLE Python GUI) ......................... 17 Slika 3.11. Hello World program napisan u jeziku Delphi (Embarcadero Delphi XE7) .............. 19

Slika 4.1. Struktura polja koje sadrži 10 elemenata ...................................................................... 20 Slika 4.2. Primjer polja u programskom jeziku C++ .................................................................... 21

Slika 4.3. Primjer polja u programskom jeziku C# ....................................................................... 21 Slika 4.4. Primjer polja u programskom jeziku Java ..................................................................... 22 Slika 4.5. Primjer polja u programskom jeziku Python ................................................................ 23 Slika 4.6. Primjer statičkog polja u programskom jeziku Delphi ................................................. 24

Slika 4.7. Struktura znakovnog niza.............................................................................................. 24 Slika 4.8. Primjer znakovnog niza u programskom jeziku C++ ................................................... 25 Slika 4.9. Primjer znakovnog niza u programskom jeziku C# ...................................................... 26

Slika 4.10. Primjer znakovnog niza u programskom jeziku Java ................................................. 27 Slika 4.11. Python - korištenje klase array i varijable za spremanje znakovnih nizova ............... 27

Slika 4.12. Primjer znakovnog niza u programskom jeziku Python ............................................. 28 Slika 4.13. Primjer znakovnog niza u programskom jeziku Delphi .............................................. 29 Slika 4.14. Primjer strukture ......................................................................................................... 30

Slika 4.15. Primjer strukture u programskom jeziku C++ ............................................................ 30

Slika 4.16. Primjer strukture u programskom jeziku C# ............................................................... 31 Slika 4.17. Korištenje klase kao zamijene za strukturu u programskom jeziku Java ................... 31 Slika 4.18. Korištenje kolekcije namedtuple u programskom jeziku Python ............................... 32

Slika 4.19. Korištenje strukture Record u programskom jeziku Delphi ....................................... 33 Slika 4.20. Korištenje klasa u programskom jeziku C++ .............................................................. 34

Slika 4.21. Korištenje klasa u programskom jeziku C# ................................................................ 35 Slika 4.22. Korištenje klasa u programskom jeziku Java .............................................................. 36 Slika 4.23. Deklariranje klasa Javi ................................................................................................ 36

Slika 4.24. Korištenje klasa u programskom jeziku Python ......................................................... 37 Slika 4.25. Korištenje klasa u programskom jeziku Delphi .......................................................... 38

Slika 4.26. Definiranje unije i struktura u jeziku C++ .................................................................. 38

43

Literatura

1. Akin E. (2001). Object Oriented Programming Concepts. Dostupno 5.9.2014. na

https://www.clear.rice.edu/mech517/Books/oop3.pdf

2. C# in Depth: Untangling the Versions. (2013); Dostupno 14.9.2014. na

http://csharpindepth.com/articles/chapter1/versions.aspx

3. Cplusplus: C++ Language. (2014); Dostupno 6.9.2014. na

http://www.cplusplus.com/doc/tutorial/

4. cs.washington.edu: CSE 341: Smalltalk intro. (2004); Dostupno 5.9.2014. na

http://courses.cs.washington.edu/courses/cse341/04wi/lectures/16-smalltalk-intro.html

5. Dawson M. (2010). Python, Uvod u programiranje (3. izdanje). Beograd: Greenfield studio

6. Delphi Wiki: Delphi. (2014); Dostupno 10.9.2014. na http://delphi.wikia.com/wiki/Delphi

7. Ecma International, Standard ECMA-334. (2006); Dostupno 14.9. na http://www.ecma-

international.org/publications/standards/Ecma-334.htm

8. Galešev V., Kralj L., Sokol G., Soldo Z., Kovač D. (2006). Informatika i računalstvo (1.

izdanje). Zagreb: SysPrint

9. Gensan Blog: Download Turbo C++ Version 3.0 (1990 Borland International, Inc).

(2011); Dostupno 6.9.2014. na http://gensanblog.com/2011/06/21/download-turbo-c-

version-3-0-1990-borland-international-inc/

10. Huang J. (2004). A Brief History of Object-Oriented Programming. Dostupno 6.9.2014. na

http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html

11. International Organization for Standardization: ISO/IEC 14882:1998. (2003); Dostupno

14.9. na

http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?ics1=35&ics2

=60&ics3=&csnumber=25845


14.9. na

http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?ics1=35&ics2

=60&ics3=&csnumber=38110

44

13. International Organization for Standardization: ISO/IEC TR 19768:2007. (2007); Dostupno

14.9. na

http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=43289


14.9. na

http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ics.htm?csnumber=5037

2&ICS1=35&ICS2=60


14.9. na

http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=42926

16. Lindsey C., Tolliver J., Lindbla T., (2005). JavaTech, An Introduction to Scientific and

Technical Computing with Java. Cambridge University Press

17. Lovrenčić, A., Konecki, M., Orehovački, T. (2009). 1957 - 2007: 50 Years of Higher Order

Programming Languages. Journal of Information and Organizational Sciences, vol. 33 no.

1, pp. 79–150

18. Lovrenčić, A. (2010). Materijali s kolegija Programiranje I. Dostupno 10.9.2014. na

http://elf.foi.hr

19. Mayo J. (2002). C# Biblioteka Ekspert. Zagreb: Miš

20. Microsoft Developer Network: System Namespace. (2014); Dostupno 8.9.2014. na

http://msdn.microsoft.com/en-us/library/system(v=vs.110).aspx

21. National Technical University of Athens: The Java Tutorials, Arrays. (2007); Dostupno

10.9.2014. na http://www.math.ntua.gr/~symvonis/other-

material/java_material/JavaTutorial/java/nutsandbolts/arrays.html

22. NetBeans: NetBeans IDE. (2014); Dostupno 9.9.2014. na

https://netbeans.org/features/index.html

23. Python Docs (2014a): History and License. Dostupno 10.9.2014. na

https://docs.python.org/2/license.html

24. Python Docs (2014b): IDLE. Dostupno 10.9.2014. na

https://docs.python.org/2/library/idle.html

25. Python Docs (2014c): 8.3. Collections. Dostupno 10.9.2014. na

https://docs.python.org/2/library/collections.html

45

26. Python Docs (2014d): 9. Classes. Dostupno 10.9.2014. na

https://docs.python.org/2/tutorial/classes.html

27. Python Wiki: Python 2 or 3. (2014) Dostupno 9.9.2014. na

https://wiki.python.org/moin/Python2orPython3

28. Radošević D. (2007). Programiranje 2. Varaždin: Tiva.

29. Saint Vincent College: Software Desing Using C++. (2013); Dostupno 10.14.2014. na

http://cis.stvincent.edu/html/tutorials/swd/basic/arrays/index.html

30. Stefik M., Daniel G. (1985). Object-Oriented Programming: Themes and Variations.

Dostupno 14.9.2014 na http://www.aaai.org/ojs/index.php/aimagazine/article/view/508/444

31. Stroustrup, B. (1996). A History Of C++: 1979-1991. Objavljeno u knjizi autora Bergin, T.,

Gibson, R.; History of Programming Languages II, str. 699-769.

32. Yahl, M. (2012). C#, CSC 415: Programming Languages. Dostupno 14.9.2014 na

http://campus.murraystate.edu/academic/faculty/wlyle/415/2012/Yahl.docx

mechanisms of aggregation in object-oriented programming

Documents