INTERNACIONALNI UNIVERZITET U NOVOM PAZARU DEPARTMAN ZA RAČUNARSKE NAUKE SMJER: INFORMATIKA
Objektno orijentisano programiranje programski jezik „Java“ Bilješke sa predavanja doc.dr.Muzafera Saračevića
Bilješke priredili studenti: Ervin Pepić, Edvin Cikotić.
Novi Pazar 2014,2015. godine
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Sadržaj Uvodna riječ ...............................................................................................................9 Java istorijat .............................................................................................................10 Nastanak Jave .......................................................................................................10 Konkretno nastanak Jave .....................................................................................10 Osnovni koncepti objektno orijentisanog programiranja ........................................12 Pregled tehnika programiranja .............................................................................12 Proceduralno programiranje.................................................................................12 Modularno programiranje ....................................................................................12 Objektno orijentisano programiranje ...................................................................12 Osnovni pojmovi objektno orijentisanog programiranja .....................................13 Java programski jezik...............................................................................................14 Java okruženje ......................................................................................................14 Najjednostavnija sintaksa Java ............................................................................15 programa koji ispisuje “zdravo svijete” na ekranu ..............................................15 Java programi .......................................................................................................15 Objektno orijentisano programiranje u Javi.............................................................15 Definicija klase ....................................................................................................16 Atributi u definiciji klase .....................................................................................17 Inicijalizacija atributa klase ................................................................................17 Korišćenje inicializacionih blokova.....................................................................17 Metode u definiciji klase ......................................................................................18 Primjer Java metode .............................................................................................19 ..............................................................................................................................20 ..............................................................................................................................20 ili ..........................................................................................................................20 Pristup atributima i metodama .............................................................................20 Pristup statičkim članovima klase........................................................................20 Pristup nestatičkim članovima klase ....................................................................21 Strana | 2
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Konstruktori .........................................................................................................21 Podrazumijevani konstrukotr ...............................................................................21 Kreiranje objekata ................................................................................................22 Prenošenje objekata metodu ................................................................................22 Destrukotri ...........................................................................................................23 Javina biblioteka klase .........................................................................................23 Biblioteka i paketi ................................................................................................23 Import deklaracije ................................................................................................24 Gdje je biblioteka????? ........................................................................................24 System ..................................................................................................................25 Println() ................................................................................................................25 Main()...................................................................................................................25 Scanner .................................................................................................................26 Promenljiva this ...................................................................................................26 THIS i nestatički metodi ......................................................................................26 Eksplicitna upotreba this-a ...................................................................................26 Final parametri .....................................................................................................27 Java paketi ................................................................................................................27 Korišćenje paketa .................................................................................................28 Pakovanje klasa ....................................................................................................28 Primjer klase Geometry .......................................................................................29 Paketi i strukutra direktorijuma ...........................................................................29 Kompajliranje paketa ...........................................................................................29 Pristup paketima ...................................................................................................30 Kontrola pristupa članovima ................................................................................30 Korišćenje pristupnih atributa i istih atributa za klasu ........................................30 Uobičajeni izbor pristupnih atributa ....................................................................31 Korišćenje ekstenzija ...........................................................................................32 Dodavanje klasa iz paketa u program ..................................................................32 Importovanje satitčkih članova klase ...................................................................33 Strana | 3
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Accesor metodi ....................................................................................................33 Mutator metodi .....................................................................................................33 Wrapper klase za primitivne tipove .....................................................................34 Nasljeđivaje ..............................................................................................................34 Nasljeđivanje klasa ..............................................................................................35 Naslijeđeni član ....................................................................................................35 Naslijeđivanje atributa .........................................................................................35 Statički atributi klase............................................................................................36 Skrivanje atributa .................................................................................................36 Skriveni atributi....................................................................................................36 Naslijeđeni metodi – osim konstruktora ..............................................................36 Naslijeđeni metodi – konstrukotri........................................................................36 Objekti izvedene klase .........................................................................................37 Pozviv baznog konstrukotra .................................................................................37 Predefinisanje (overriding) metoda bazne klase ..................................................38 Izbor pristupnih atributa bazne klase ...................................................................38 Višestruk nasljeđivanje i interfejsi ...........................................................................39 Interfejsi ...............................................................................................................39 Deklarisanje interfejsa .........................................................................................40 Korišćenje interfejsa ............................................................................................41 Proširivanje interfejsa ..........................................................................................41 Polimorfizam ............................................................................................................41 Apsraktne klase ....................................................................................................42 Grafičko programiranje – Java.................................................................................43 Graphical User Interfeace – GUI – Grafički korisnički interfejs ........................43 Kreiranje prozora .................................................................................................44 Komponente i kontejneri......................................................................................46 Window i Frame komponente ..............................................................................47 Prozorski okvir (Window Panes) .........................................................................47 JavaScript .................................................................................................................47 Strana | 4
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Pozivanje unutar HTML dokumenta ...................................................................48 Pozivanje eksternih skriptova ..............................................................................49 Tipovi podataka....................................................................................................49 Izrazi i operatori ...................................................................................................50 Rezervisane ili ključne riječi ................................................................................50 Komandni blokovi................................................................................................51 Izlaz iz JavaScripta...............................................................................................51 Alert() ...................................................................................................................52 Funkcije ................................................................................................................52 Prosljeđivanje funkcija.........................................................................................53 Ugrađene funkcije JavaScripta ............................................................................54 Događaji u JavaScriptu ........................................................................................55 Objekti u JavaScriptu ...........................................................................................55 Osobine ................................................................................................................56 THIS .....................................................................................................................57 Kreiranje novog objekta .......................................................................................57 Ugrađeni objekti JavaScripta ...............................................................................57 Kreiranje nizova u JavaScriptu ............................................................................58 Pojam i struktura Java Aplet ....................................................................................59 Primjer ugrađivanja apleta u HTML :..................................................................59 Rad sa događajima ...............................................................................................60 Action Event ........................................................................................................60 KeyEvent ..............................................................................................................61 MouseEvent .........................................................................................................61 Uporedni prikaz Java Appleta i Java Aplikacije..................................................62 Bezbijednost Java Apleta .....................................................................................62 Pojam i struktura Java servleta ................................................................................63 Arhitektura Servlet paketa ...................................................................................63 Posao servleta .......................................................................................................64 Veza klijent – server ............................................................................................64 Strana | 5
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java Servleti ....................................................................................................65 Osnovna struktura servleta ...................................................................................65 Interakcija sa klijentom ........................................................................................66 ServletRequest .....................................................................................................66 ServletResponse ...................................................................................................67 Primjer jednostavnog servleta ..............................................................................67 Prednosti Java servleta .........................................................................................68 Nedostaci Java servleta ........................................................................................68 Java Server Pages .....................................................................................................68 Višeslojne veb aplkacije...........................................................................................69 Izrada standardnih troslojnih veb aplikacija ............................................................69 Troslojna arhitektura ............................................................................................69 Višeslojna arhitektura ..........................................................................................69 Rad sa bazama podataka u Javi ................................................................................70 SUBP / JDBC .......................................................................................................70 Razmena podataka između BP i Aplikacija – JDBC ...........................................71 Razmjena podataka između Baze podataka i aplikacije ......................................72 Pristup bazi podataka iz Java aplikacije ..............................................................73 Servleti ................................................................................................................73 ODBC/JDBC........................................................................................................74 JDBC ....................................................................................................................74 Arhitektura JDBC sistema ...................................................................................74 Primejr upotrebe JDBC sistema ...........................................................................76 JDBCAPI .............................................................................................................78 Osnovne kalse ......................................................................................................79 Elementi JDBC Drajvera .....................................................................................79 Exceptions ............................................................................................................79 Connections ..........................................................................................................80 Objektno orijentisana metodologija razvoja softvera ..............................................81 Reinženjering i restruktuiranje .............................................................................81 Strana | 6
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Tri tipa inženjeringa OOAD metodologija ..........................................................82 ..............................................................................................................................83 Domen Objektno Orijentisanog reinženjeringa softvera .....................................83 Ideje reinženjering softvera..................................................................................84 Reinženjering ili ponovni razvoj..........................................................................84 Ograničenje reinženjeringa ..................................................................................84 Glavni pristupi reinženjeringa..............................................................................84 Prevođenje izvornog koda....................................................................................84 Restruktuiranje programa.....................................................................................85 Problem sa primjenom alata.................................................................................85 Reinženjering podataka ........................................................................................85 Reverzibilni inženjering .......................................................................................85 Process reverzibilnog inženjeringa ......................................................................86 Razumijevanje programa .....................................................................................86 Redokumentacija ..................................................................................................86 Redizajn-obnova dizajna ......................................................................................87 Respecifikacija .....................................................................................................87 Rekodiranje ..........................................................................................................87 Kategorije reinženjeringa .....................................................................................87 Rezultat reinženjeringa ........................................................................................88 Refaktorisanje ..........................................................................................................88 Zašto vršiti refaktorisanje ....................................................................................89 Kata treba vršiti refaktorisanje .............................................................................89 Kata ne treba vršiti refaktorisanje ........................................................................89 Kako započeti refaktorisanje................................................................................90 Šta treba refaktorisati ...........................................................................................90 Izdvajanje metoda ................................................................................................90 Motivacija ................................................................................................................91 Mehanizam ...........................................................................................................91 Zamjena privremene promenljive upitom(replace temp with query) ..................91 Strana | 7
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Razdvajanje privremene promenljive(split tempororay variable) .......................92 Zamjena metoda objektom metoda(Replace Method With Method Object) ......92 Prmeštanje metoda(move method) ......................................................................92 Izdvajanje klase (extract class) ............................................................................92 Zamjena prostog podataka objektom(repace data value with object) .................92 Alati za refaktorisanje ..............................................................................................93 Završna riječ .............................................................................................................94
Strana | 8
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Uvodna riječ Ako želite potupuno da razumijete Javu, morate da razumijete razloge koji su uticali na njeno stvaranje, sile koje su je uobličilie i elemente koje je dobila u nasljeđe. Slično uspješni programskim jezicima koji su joj prethodili i Java je mješavina najboljih elemenata svog bogatog nasljeđa, kombinovanih sa novim koncepcijama neophodnim za njenu jedinstvenu misiju. Iako je postala nerazdvojivi dio mrežnog okruženja interneta, treba istaći da je Java na prvom mjestu programski jezik. Poboljšanje računarskih jezika i njihovo razvijanje nastaju iz dva osnovna razloga: Da bi se jezici prilagodili izmijenjenom okruženju i novoj primjeni. Da bi se u jezike ugradila poboljšana i novosti na polju programiranja.
Strana | 9
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java istorijat Java je srodnik jezika C++, koji je direktan potomak jezika C. veći dio svojih osobina Java je naslijedila od ova dva jezika. Iz jezika C Java je preuzela sintaksu. Mnoge od objektno orijentisanih osobina jave nastale su pod uticajem jezika C++. U stvari, više karakteristika koje definšu Javu potiču od njenih predhodnika ili su nastale kao odgovor na njih. Štaviše, nastanak Jave ima duboke korijene u procesima poboljšanja i prilagođavanja koja su se tokom posljednjih decenija odvijali na polju programskih jezika.
Nastanak Jave Krajem osamdesetih ,početkom devedesetih godina, objektno programiranje na jeziku C++ uzelo je maha. I zaista, za trenutak je izgledalo da su programeri konačno pronašli savršen programski jezik. Pošto programski jezik C++ obedinjuje visoku efikasnost i stilske elemente C-a sa objektno orijentisanim pristupom, mogao se koristiti za pravljenje široke lepeze programa. Međutim baš kao toliko puta u prošlosti, ponovo je narasla potreba da se računarski jezici pomaknu za još jedan stepenik u svojoj evaluaciji. Za nekoliko godina World Wide Web i internet poprimiće svoj sadašnji oblik, a ovaj događaj će začeti novu revoluciju na polju programiranja.
Konkretno nastanak Jave Javu su prvobitno , 1991 godine koncepirali James Gosling, Patrick Naughton, Chris Warth, Ed Frank i Mike Sherdian, iz korporacije Sun Microsystem, Incorporate. Trebalo je 18 meseci rada da bi se došlo do prve radne verzije. Ovaj jezik je prvobitno dobio ime “OAK” ali je on 1995 godine promijenjen u “Java”. U periodu od prve realizacije OAK sa jeseni 1992 godine i zvaničnog najavljivana Jave 1995 godine još mnogo osoba je doprinijelo u oblikovanju i razvianju ovog jezika. Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin i Tim Lindholm bili su glavni saradnici na usavršavanju prvobitnog prototipa Donekle iznenađuje to što glavni pokretač za razvoj Jave nije bio internet, osnovni motiv je bila potreba za jezikom nezavisnim od računarske platform(tj.neutralnim u odnosu na arhitekturi), koji bi se mogao koristiti za pravljenje softvera namijenjenog za pravljenje softvera različitim elektronskim Strana | 10
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
uređajima domaćinstvu: kao što su mikrotalasne pećnice i daljinsi upravljači. Možda i sami pogađate da se kao kontroleri ovakvih uređaja koriste različiti tipovi proceora. Problem sa jezicima C i C++ (kao is a većinom drugih jezika), leži u ome što se pri prevođenju u binarni oblik oni moraju usmjeriti na određeni procesor. Iako se program pisan u jeziku C++ može prevsti za bilo koji procesor, za to je potreban potupun prevodilac namijenjen konkretnom procesoru. Teškoća je u tome što su prevodioci skupi i teško se prave. Očigledno da je bilo potrebno lakše i bolje rješenje. U pokušaju da dođu do njega, Gosling i ostali su počeli da rade na prenosivome jeziki koji ne zavisi od platform i čiji bi kod mogao da se izvršava na različitim procesorima i u različitim okruženjima. Ovi napori su konačno doveli do rađanja Jave. Štaviše, pošto se većina korisnika računara svrstava u tri konkurentska tabora: INTEL, MACINOTSH i UNIX, najveći broj programera se zadržavao unutar svojih utvrđenih granica i potreba za prenosivim kodom izgubika je svoj primarni značaj. Međutim, sa razvojom Internata i WWW, stari problem prenosivosti ponovo se pojavio u punoj snazi. Internet predstavlja raznoliki, distribuiran univerzum ispunjen mnogim vrstama računara i procesora. Internet prikljčene mnoge različite platform korisnici bi željeli da nad svim može da se izvrašava isti program. Ono što je jednom bilo neugodan ali malo značajan problem, postalo je problem koji je pod hitno trebalo riješit. I 1993 godine članovima tima za razvoj Jave postalo je jasno da se problem prenostivosti , s kojima su često sretali pri programiranju koda za kontrolore elementarnih uređaja pojavljuje i pri pravljenju koda za Internet. U stvari, isti problem zbog kojeg je Java prvobitno smišljena, pojavio se i na Internetu – samo u velikom obimu. To je prouzrokovalo da se focus primjene Jave sa kućne elektronike na programiranje za Internet. Dakle, prmda je želja za ostvarenje programskog jezika koji ne zavisi od platforme bila početni moti,v za uspjeh Jave na visokome nivou zaslušniji je internet. Java nije jezik koji postoji samo za sebe, već predstavja sadržajni izraz jednog procesa koji je započeo pre mnogo godina. Samo ova činjenica dovoljna je da Javi obezbijedi mjesto u istoriji računarskih jezika. Za programiranje na internet Java predstavlja ono što je bio C za sistesko programiranje, revolucionarnu snagu koja je izmijenila svijet. Uspjeh Jave bio je toliki da ga je nemoguće ignorisati. Jezik C# možda je najvažniji primjer Javinog uticaja, jer joj je veoma blizak. Microsoft je razvio C# kao podršu svoje tehnologije .NET Framework. Oba jezika imaju istu opštu sintaksu, podržavaju distribuirano programiranje i koriste isti model objekata.
Strana | 11
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java je veoma dobro rješenja za pisanje klijent aplikacija koje ne vrše veliku obradu podataka, već to prepuštaju serveru, kao i za pisanje manjih programa(apleta)koji čine elemente multimedijalnih prezentacija na internet.
Osnovni koncepti objektno orijentisanog programiranja Pregled tehnika programiranja Proceduralno programiranje, Modularno programiranje, Objektno orijentisano programiranje.
Proceduralno programiranje Program se može posmatrati kao sekvenca poziva potprograma (procedura). Višestruko korišćenje koda postiže se preko biblioteka procedura i funkcija. Kocetriše se na procedure – niz akcija. Jedinicia programiranja – funkcija, funkcije se grupišu u programe.
Modularno programiranje Procedure sa zajedničkom funkcionalnošću su integrisane u jedan modul. Svaki modul može da ima svoje sopstvene podatke. Višestruko korišćenje struktura podataka i procedura.
Objektno orijentisano programiranje Structure podataka i procedure integrisane u kalse.
Strana | 12
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Program može da se posmatra kao mreža objekata koji su u interakciji pri čemu svaki objekat zna svoje stanje. Apstrakcija, enakpsulacija, nasljeđivanje i polimorfizam. Ponovno korišćenje objekata.
Osnovni pojmovi objektno orijentisanog programiranja
objekat,primjerak klase, instanca, klasa (operacije i atributi), metode ,funkcije ,operacije, promenljive ,varijable,podaci i atributi.
Objektno orijentisano programiranje zasnovano je na konceptu objekata. Objekti su struktura podataka sa pridruženim skupo procedura i funkcija koje se nazivaju metode i služe za operisanje podacima koji čine objekat. U pravim objektno orijentisanim programskim jezicima, metode su jedini način operisanja podacima koji su sadržani u objektima. Svaki objekat predstavlja primjerak(instancu) neke klase. Definisanjem klase definiše se kao sadržaj objekata te klase, tako i skup metoda. Klase se mogu formirati na osnovu postojećih postupkom nasljeđivanja, čime se omogućuje kreiranje hijerarhije klasa. Jednostruko nasljeđivanje, Višestruko nasljeđivanje, Polimorfizam. Objekti su oko nas u realnom svijet, ljudi razmišljaju o stvarima oko sebe na objektno orijentisan način. Objekti imaju neke karakteristike, svojstva, attribute, kao i određena ponašanja. Različiti objektn mogu imati slične attribute i ponašati se na sličan način.
Strana | 13
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java programski jezik Java je srodnik jezika C++, koji je direktan potomak jezika C. veći dio svojih osobina Java je naslijedila od ova dva jezika. Iz jezika C Java je preuzela sintaksu. Mnoge od objektno orijentisanih osobina jave nastale su pod uticajem jezika C++. U stvari, više karakteristika koje definšu Javu potiču od njenih predhodnika ili su nastale kao odgovor na njih. Java programi mogu da rade na svakoj platform koja podržava Javu zahvaljujući sledećem: Java program se ne izvršava direktno na računaru već na standardizovanom okruženju (Java platforma) koja se sastoji od 2 elementa: Java Virtual Machine(JVM) – softverska implementacija hipotetičkog računara. Java Application Programming Interface (Java API) – skup softverskih komponenata koje obezbeuju pisanje interaktivnih aplikacija. Java kompajler predvodi Java izvorni kod u takozvanom byte kod koji predstavlja mašinske instrukcije za Javu VM . kada se izvršava Java program koji se zove Java interpreter tumači bytecode i zatim izvršava akcije koje bytecode specificira unutar Java VM.
Java okruženje Pošto se Java kod sastoji od bytecode, a ne od pravih mašinskih instrukija, on je potpuno nezavisan od hardvera na kome se izvršava. Svaki računar koji ima implementirano Java okruženje izršiće taj program podjednako dobro kao i svaki drugi, a Java interpreter, koji se nalazi između programa i fizičke mašine sprečiće neautorizovane akcije programa.
Strana | 14
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Najjednostavnija sintaksa Java programa koji ispisuje “zdravo svijete” na ekranu Public class zdravo{ Public static void main (string[] args){ System.out.println(“Zrdavo svijete”); } } Kompajler generiše bytecode program koji je ekvivalent soruce kodu. On se smešta sa istim imenom i ekstenzijom .class. Prevod svake klase se smešta u zaseban fajl sa ekstenzijom .class i imenom isti kao ime kalse.
Java programi Postoje dvije osnovne vrste programa koji se mogu pisati u Javi: Aplikacija , Aplet. Aplikacija samostalni program za rješavanje jednog ili skupa problema, koji sadrži metodu main() i jednu ili više klasa. Aplet je dinamički interaktivni program koji se može izvršiti u okviru web stranice, a posredstvom nekoga od browsera.
Objektno orijentisano programiranje u Javi Objekat je integralna cjelina podataka i procedura za rad sa njima. U objektno orijentisano programiranju ,glavne obrade se zasnivaju na manipulisanju objektima. Metod je funkcija koji je je sastavni dio objekta, tj.postupak kojima se ralizuje poruka upućena objektu. Poruka je skup informacija koje jedan objekat šalje drugom, a sastoji iz adrese objekta ,primaoca, saopštenja tj.onog što treba da se radi.
Strana | 15
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Definicija klase Klasa je skup objekata sa zajedničkim svojstvima koji se ponašaju na isti način. Ona definiše šablon za kreiranje instanci, tj.konkretnih objekata klase. Ona omogućuje da se zadaju opšta svojstva , a njihovim konkretizovanjem dobijamo instnacu. Klasa se može shavtiti kao novi tip, ona određuje koje vrijednosti mogu dobiti promenljive(objekti tog tipa i koje operacije se mogu vršiti nad njima). Definicija klase je jako jednostavna i može sadržati samo atribute i metode. class Krug{------ klasa Krug int x, y; float r; } Krug k= new Krug (10,20,5); <----- instanca klase Krug Instanca je konkretan objekat klase. Svi metodi definisani u klasi mogu se primijeni na instancu. Konvenvija je da klasa u Javi počinje velikim slovom. Za atribute ,kako statičke tako i nestatičke , se u definiciji klase mogu postaviti inicijalne vrijednosti. U koliko se ne navede inicijalna vrijednost prilikom kreiranja objekata biće pridružena default vrijednost i to: 0 – za numeričke tipove, -'\u0000' za tip char Null – za refernce na objekte i reference na nizvoe. Atributi klase Promenljive iz definicije klase nazivaju se atributi klase ili instance promenljive ili instance klase. Klasom je definisan njihov tip, a za svaku instancu instancna promenljiva ima konkretnu vrijednost. U predhodnom primjeru x, y i r su instance promenljive, koje u instance k imaju redom vrijednosti (10,20,5). Instance promenljive mogu biti nekog od promenljivih, ali takođe i klasnih tipova. Strana | 16
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Atributi u definiciji klase Atributi mogu biti proizvoljnog tipa ili reference na objekte proizvoljne klase, uključujući klasu koju definišemo. Postoje dvije vrste atributa: - Statički atribut, - Nestatički Statički atribut je zajednički za sve objekte klase. Postoji samo jedna kopija tog atributa bez obzira na to koliko objekata te klase je kreirano, i ta kopija postoji čak i kada nije kreiran ni jedan objekat te klase. Deklarišu se navođenjem ključne riječi static ispret
. Statički atributi se koriste da čuvaju podatke koji su zajednički za sve objekte. npr: brojač koliko objekata klasa je trenutno kreirano pošto je static može se koristiti čak i kada nije kreiran ni jedan objekat te klase. Nestatički – svaki objekat klase posjeduje svoju sopstvenu kopiju svakog od nestatičkih atributa koji se pojavljuju u definiciji te klase, i ti atributi imaće svoje sopstvene vrijednosti, nezavisno od odgovarajućih vrijednosti tih atributa u drugim objektima. Ovakvi atributi daju objektima individualnost . nestatički atributi se u definiciji kalse deklarišu na uobičajen način: i eventualno se može zadati inicijalna vrijednost.
Inicijalizacija atributa klase I statički i nestatički atributi se mogu inicijalizovati unutar definicije klase. Neke stvari se ne mogu inicijalizovati jednim izrazom, na primjer veliki niz koji želimo inicijalizovati vrijednostima koje iziskuju neku vrstu izračunavanja. To je posao za inicializacioni blok.
Korišćenje inicializacionih blokova Inicializacioni blok je blok coda između{i} koji se izvrašava pri kreiranju objekta klase. Strana | 17
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Postoje dvije vrste inicijalizacionih blokova: Statički inicializacioni blok Nestatički inicializacioni blok Statički inicializacioni blok – ključna riječ static izvršava se jedanput, pirlikom učitavanja klase. Može inicijalizovati samo statičke atribute klasa. Nestatički inicializacioni blok, izvršava se za svaki objekat koji se kreira i inicijalizuje nesatatički atribut klase. Iako je moguće,normalno ne treba inicijalizovati statičke atribute ne statičkim inicializacionim blokom.
Metode u definiciji klase Metodi su zapravo funkcije i tako se i definišu. Tip vrijednosti koju metod vraća može biti void ili proizoljan tip (int,string..). lokalne promenljive se ne inicijalizuju automatski, već se mora eksplicitno izvršavati njihova inicijalizacija(inače ne prolazi kompajler). Argumetni se prenose po “po vrijednosti” ,tj.prenose se lokalne kopije argumenata, pa tako ako je argument promenljiva primitivnog tipa, funkcija ne može promijeniti njenu vrijednost. Iako se mehanizam prenošenja argumenata po vrijednosti primjenjuje na sve tipove argumenata, efekat za objekte se realizuje od onog za promenljive primitivnih tipova. Objekat se može promijeniti jer promenljiva klasnog tipa sadrži reference na objekat a ne samo objekat. Kada se takva promenljiva prenese kao argument metoda, prenose se kopije reference na objekat, a ne kopija samog objekta. Kao i kod atributa , tako i ovdje postoje dvije vrste metoda: Statički, Nestatički. Statički(static)mogu se izvršavati čak i kada ne postoji ni jedan objekat te klase.
Strana | 18
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Pošto se statički metodi mogu pozivati i kada ne postoje konkretni objekti klase, oni ne mogu koristiti nestatičke atribute. U koliko se u kodu statičkog metoda referiše nestatički atribut, kompajliranje neće proći. Definiše se tako što se doda ključna riječ static ispred definicije metoda. Sada postaje jasno zašto metoda main()od koga kreće izvršavanje aplikacije mora da se definiše kao statički, jer prije startovanja aplikacije ne postoji ni jedan objekat. Nestatički metodi se mogu izvršavati samo za konkretne objekte. Iako su nesatitčki metodi specifični za objekte klase, postoji samo jedna kopija svakog od ovih metoda u memoriji i nju dijele svi objekti te klase, jer bi bilo extremno skupo praviti kopiju svakog nestatičkog metoda za svaki objekat. Sav izvršni Java kod mora biti unutar klase, ali se za većinu funkcija opšte namjene nije neophodna veza sa konkretnim objektom: Najbolji primjeri statičkih metoda su matematičke funkcije implementirane u standartnoj klasi Math. Ovi metodi uopšte ne rade sa objektima klasa, operišu isključivo sa primitvnim tipovima. Npr: računanje kvadratnog korijena ili generisanje slučajnog broja. Pa se one definišu kao static. Važno je zapamtiti da se unutar statičkih metoda ne mogu referisati nestatički atributi, jer se ovakvi metodi mogu pozivati i kada nije kreiran nijedan objekat klase, u kom slučaju i ne postoji ni jedan nestatički atribut.
Primjer Java metode int povrsina(){
int povrsina(){
int p; p=s*v; return (p);
return (s*v);
}
}
}
Strana | 19
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
ili
double dijagonala(){ double d; d=Math.sqrt(Math.pow(s,2)+Math.pow(v,2));
ili
return (d); } double dijagonala(){ return(Math.sqrt(Math.pow(s,2)+Math.pow(v,2)); }
Pristup atributima i metodama Obično hoćemo da pristupimo atributima i metodama izvan klase u kojoj su definisani. Atribute i metode je moguće definisati i tako da im pristup izvan klase nije moguć. Pristup atributima u metodi: Nestatički metod može pristupiti proizvoljnom atributu klase (i statičkom i ne statičkom)korišćenjem samo njegovog imena.
Pristup statičkim članovima klase . Primjer: double rPi =Math.sqrt(Math.Pi); Ukoliko postoji referenca na objekat klase, statičkom članu se može pristupiti i sa : .. Ovo je moguće jer svaki objekat uvijek ima pristup svim statičkim članovima klase. Imena statičkih članova klase mogu se importovati koriščenjem import deklaracija, a onda se ti članovi mogu koristi bez kvalifikovanja imenom klase,prosto navođenjem njihovih imena. Strana | 20
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Pristup nestatičkim članovima klase Moguće je samo koristeći reference na konkretne objekte: ..
Konstruktori Konstruktori su specijalne metode klase, imaju isto ime kao i klasa ,inicijalizjz podatke članova klase. Pozivaju se automatski kada se kreira objekat klase. Nemaju povratni tip, može se definisati više konstruktora(overloading). Možemo imati više inicializacionih blokova i onda se oni izvršavaju onim redom kojim su navedeni u definiciji klase. Iako su inicializacioni blokovi korisni, za krerianje objekata potrebni su nam i konstruktori. Uvijek kada kreiramo objekat neke klase poziva se specijalna vrsta metode tzv.konstruktor. Ukoliko ne definišemo ni jedan konstrukotr za našu klasu,kompajler će obezbijediti podrazumijevani konstrukotr klase koji ne radi ništa. Primarna svrha konstruktora jeste da za objekat koji se kreira izvrši inicijalizaciju nestatičkih atributa. Inicializacioni blokovi koji su eventualno definisani u klasi uvijek se izvršavaju prije tijela konstrukotra. Konstruktor ima dvije specifične osobine: Nikada ne vraća vrijednost, Uvijek ima isto ime kao i klasa kojoj pripada. Konstruktor može imati proizvoljan broj parametara, uključujući i 0 bez parametara. Podrazumijevani konstrukotr nema parametre.
Podrazumijevani konstrukotr (){}
Strana | 21
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Ukoliko smo definisali nestatičke Podrazumijevani Inicializacione blokove u klasu, oni se izvršavaju svaki put kada se izvršava i konstruktor, neposredno prije izvršavanja tijela konstruktora. Konstrukotr se poziva kad god kreiramo objekat, ukoliko sami napišemo bar jedan konstrukotr, kompajler ne pravi podrazumijevani konstruktor. Ako nam je i on potreban, moramo ga eksplicitno definisati.
Kreiranje objekata Da bismo kreirali objekat klase moramo koristi ključnu riječ new za kojom slijedi poziv konstrukotra . Da inicijalizujemo b referencom na objekat: b=new S(10.0, 1.0, 1.0, 1.0); može i sve u jednom redu: S b=new S (10.0, 1.0, 1.0, 1.0); // deklariše se promenljiva b i definiše objekat. //na koji ona referiše. Kreiranje nove promenljive koja reriše na isti objekat: S myB =; I dalje imamo jedan objekat ali sada dvije promeljive koje na njega referišu. Možemo imati koliko kod takvih promenljivih koje referišu na isti objekat.
Prenošenje objekata metodu Kada prenesemo objekat metodu, primjenjuje se mehanizam prenošenja po referenci jer se metodu prenosi kopija reference na objekat sadržine u promenljivoj, a ne kopija samog objekta.
Strana | 22
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Destrukotri Destrukotri za razliku od konstrukotra imaju zadatak da oslobde memoriju nakon što je konstruktor zauzeo lokaciju. Imaju takođe isto ime kao i klasa, nemaju argumente, nema preklapanja, izvršavaju radnje kod uništavanja objekata i pozivaju se automatski.
Javina biblioteka klase Java jezik je sa hijerarhijskom strukturom kalsa, sve one su podklase kalse OBJECT, što je preuzeto iz SMALTALLK-a, pruža mogućnost rada sa interfejsima – skup imenovanih metoda koji nisu naslijeđeni od nadklase, niti definisani u samoj klasi, a koji određuju neka dodatna svojstva klase, bibiloteka u javi je kolekcija klasa i interfejsa.
Biblioteka i paketi Biblioteka se sastoji od fajlova ,pri čemu svaki fajl sadrži definiciju odgovarajuće klase. Klase su grupisane u tzv.pakete, a svaki paket je smješten u posebnom folderu. Klasa iz paketa može pristupiti proizvoljnoj klasi iz istog paketa. Klase iz drugih paketa mogu, a ne moraju biti dostupne. Ime paketa bazirano na putanji do foldera u kome su smještene odgovarajuće klase tog paketa. Naši paketi koji sadrže naše klase koje želimo ponovo da koristimo u različitim kontekstima. Java raspolaže ogromnim brojem standardnih paketa, a najkorišćeniji su :
Java.lang, Java.io Java.util Javax.swing Java.awt.
Java.lang osnovne karakteristike jezika, rad sa nizovima i stringovima. Klase iz ovog paketa su uvijek dostupne našem program – automatski se uključuju u naš program(klase integer ,string,math….). Java.io klase za ulazno izlazne operacije. Strana | 23
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java.util klasa Vector(uopšeni niz), Stack,Scanner, klase za rad sa datumima, matricama i druge klase raznih vrsta. Javax.swing jednostavna za upotrebu i fleksibilne komponente za pravljenje GUIja (tzv. Swing komponente). Java.awt originalne GUI komponente i osnovna podrška za neke swing komponente.
Import deklaracije Da bismo koristili klase bez navođenja njihovog punog kvalifikovanog imena (koje uključuje ime paketa i ime klase), tj. Samo navođenjem njiovog imena, koristimo import deklaraciju sa imenom paketa ili pojedinačne klase. Import javax.swing.JApplet; Import javax.swing.*// biće uključene sve klase iz paketa.
Gdje je biblioteka????? Standardne klase se ne pojavljuju kao fajlovi i folderi na našem disku. One su spakovane u jedan komprimovani fajli rt.jar koji se nalazi jre/lib folderu koji se kreira prilikom instalacije JDK –a. Standardne klase koje naš izvršni fajl zahtijeva direktno se učitavaju iz jre/lib. Public class PrviProgram { Public static void main (string [] args){ System.out.println(“Selam”); } } Void- znači da funkcija ne vraća nikakvu vrijednost, Public – znač da je metod globalno dostupan, Static – dostpuan i kada ne postoje objekti klase, Sa args.length možemo odraditi dužinu niza.
Strana | 24
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
System System je ime standardne klase koja sadrži objekte za rad sa standardnim ulazno – izlaznim uređajima : tastatura za ulaz, monitor za izlaz. Sadržana je u paketu java.lang pa je u programima koristimo prosto navođenjem samo njenog imena system. Objekat out predstavlja standarni izlazni tok i on je statički član klase system, što znači da on postoji čak i kada ne postoji nijedan objekat tipa System. System.out => notacija: out je član klase System.
Println() Println() metod pripada objektu out i on ispisuje string koji je zadat pod dvostrukim navodnicima. Ovdje vidimo i jedan od načina za pozivanje klasnog medota , Ukoliko kompilacija ne prođe , česti uzroci mogu biti: PATH nije uključen ili nije ispravno uključen, Case-sensitive: imena klasa i fajla se moraju potpuno poklopiti, i u njima ne smiju postojati bjeline. . , ; su bitni znaci i moraju biti na svojim mjestima (), {}, [], uvijek dolaze u paru i ne prepliću se
Main() Svaka Java aplikacija sadrži klasu koja definiše metod main() . Ime te klase je argument koji prosleđujemo Java interpretatoru. Main() metod mora imatei fiksnu formu i ukoliko ona nije ispoštovana neće biti prepoznata od strane Jave interpretatora kao metod od koga kreće izvršavanje. Najjednostavnija Java aplikacija sastoji se samo od jedne klase koja ima samo jedan, main() metod Prototip main() metoda je uvijek oblika: Public static void main(String[]args).
Strana | 25
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Scanner Java.util.Scanner klasa, jednostavni skener koji parsira primitvne tipove i stringove koristeći regularne izraze. Ulaz može biti fajl ili tok uključujuči i standardni ulazni tok syste.in. Ulaz se dijeli na tokene, koristeći kao delimiter po podrazumijevanom u blanko. Dobijeni tokeni se mogu konvertovati u vrednosti različitih tipova koristeći razne next metode. Scanner sc-new Scanner (System.in); Int i=sc.nextInt();
Promenljiva this Svaki nestatički metod ima promenljivu koja se zove this koja predstavlja referencu na tekući objekat za koji je metod povezan. Kompajler implicitno koristi this kada metod referiše nestatički atribut klase. Možemo i samo napisati this.. Nije dobra praksa na taj način nepotrebno opterećivati kod. A postoje i situacije kada je neophodno explicitno koristiti this.
THIS i nestatički metodi Promenljiva THIS omogućava da jedna instanca metode radi sa različitim objektima klase. Prilikom svakog poziva nestatičkog metoda, promenljiva this se postavi da referiše na objekat za koji je metod pozvan i onda se cod u metodi odnosi na članove upravo tog objekta.
Eksplicitna upotreba this-a Dozvoljeno je koristiti imena lokalnih promenljivih, kao i imena parametara metoda koja su ista kao i imena atributa. U tom slučaju, neophodno je koristiti this za referisanje člana klase unutar metode. Samo ime promenljive če se uvjek odnositi na lokalnu promenljivu metodu, ne na atribute klase. Strana | 26
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Void change R(double r){ this.r=r; } This.r se odnosi na atribute, a r na parametar metoda.
Final parametri Svaki parametar metoda može se navesti i kao final čime se sprečava da funkcija promijeni njegovu vrijedonst. Pošto se parametric prenose po vrijednosti, final ima smisla samo za parametre koji su reference na objekte klasa. Međutim time se sprečava promjena reference na objekat koja se prosleđuje metodi, a ne promjena samog objetkta. Primjer: kada izvršimo naredbu : double c=A.B(); gdje je A objekat odgovarajuće klase, this u metodi B () referisaće na objekat A.
Java paketi Paket predtavlja jedinstveno fundamentalnu imenovanu kolekciju klasa, paketi su fundamentalni za Java programi. Paketi su implicitno u organizaciji standardnih klasa i naših programa i oni određuju koja imena možemo koristiti za klase, kao i atribute i metode koje one sadrže. Imena klasa jednog paketa neće se miješati sa imenima klasa drugog paketa jer se imena klasa paketa kvailifikuju imenom tog paketa. Npr: puno ime klase String iz pakata java.lang je: java.lang.String. Ako bismo definisali svoju klasu sa istim imenom, String, korišćenje imena Strig odnosilo bi se na tu našu klasu, dok bismo se standardnoj klasi String morali obraćati sa java.lang.String. Svaka klasa u Javi je sadržana u nekom paketu. Standardne Java klase su sadržane u paketima tako što se u jednom paketu nalaze klase koje su na neki način povezane. Način grupisanja međusobno povezanih klasa i interfejsa. Način oragnizovanja klasa u grupe. Paketi sadrže klase povezane zajedničkom svrhom. Strana | 27
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Paketi mogu da sadrže druge pakete , svaki nivo predstavlja malo određenije grupisanje klasa. Biblioteka klasa u Javi sadržana je u paketu nazvanom java. Io,net,util,swing,awt. Paketi su korisni iz sjedećih razloga:
Omogućavaju organizaciju klasa u jedince(units). Smanjuju problem konflikta naziva. Omogućavaju bolju zaštitu. Mogu se koristiti za identifikaciju klasa.
Korišćenje paketa Da bi se pozvala klasa iz drugog paketa mora se koristi pun naziv kase kao npr: Naziv_paketa.naziv_klase : Npr: java.awt.Font. Korisno je za klase koje se koristo jednom ili dva puta u cijelom programu. Mehanizam korišćanja klase koja je u nekom paketu: Klasa iz java.lang paketa su automatski dostupne. Korišćenje klase iz drugog paketa. Korišćenje klasa iz uvezenih paketa (komanda import). Komandom import se uvoze klase iz paketa: Uvoz individualne klase (import java.awt.Font), Uvoz cijelog paketa klasa(import java.awt.*), Nepohodno je navesti svaki nivo hijerarhije (import java.wat.image.*) Import se nalazi na vrhu datoteke prije defincije klase.
Pakovanje klasa Ako želimo da klasa paketa bude dostupna i izvan njega, potrebno je deklarisati klasu koristeći ključnu riječ public u prvoj liniji definicije klase. Ukoliko
Strana | 28
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
ispred definicije klase ne postoji ključna riječ public, definicija te klase je dostupna samo u metodama klasa koje se nalaze u istom paketu. Stavljanje klase z imenovani paket je jednostavno, samo je potrebno dodati package deklaraciju kao prvu liniju fajla koji sadrži definiciju klase, package deklaracija ima oblik: Package;
Primjer klase Geometry Sva klasa koju hoćemo da uključimo u paket Gemotry mora da sadrži istu package deklaraciju na početku i svi fajlovi koji sadrže definicije klasa tog paketa moraju se sačuvati u direktorijumu koji ima isto ime kao paket odnosno Geometry. Takođe, metode i konstruktore unutar public ako hoćemo da budu dostupni izvan paketa.
Paketi i strukutra direktorijuma Paketi su usko povezani sa strukutrom direkotrijuma u kojoj se čuvaju. Možemo generisati .class fajl za neku klasu iz paketa u drugom direktorijumu, ali taj direktorijum takođe mora imati isto ime kao i paket. Ime paketa može biti složeno, npr:Geomtery.Shapes3D, što znači da je Shapes3D poddirektorijum direktorijuma Geometry. Ime može biti proizvoljne složenosti, alit treba da održava strukturu direkotrijuma u koju je paket smješten.
Kompajliranje paketa Korišćenjem JDK pod Windows-om. Putanja do direktorijuma paketa mora biti eksplicitno naznačena kompajleru pomoću vrijedonsti koja se postavlja za CLASSPATH čak i kada tekući direktorijum sadrži paket. Najjednostavniji način za postavljanje CLASSPATH-a je navođenjem opcije –classpath pri pozivu kompajlera. Ako smo izvorne fajlove klase paketa Geomtery smjestili u direktorijum sa putanjom C:\Java Prog\Geometry, putanja do C:\Java Prog, a NE C:\Java Prog\Geometry
direktorijuma
Geometry
je:
Strana | 29
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Java –classpath “C:\Java Prog” Line.java. Putanju je neophodno smjestiti među dvostruke navodnike jer sadrži bjeline. Javac –classpath “C:\Java Prog”*.java //svi izvorni fajlovi.
Pristup paketima Ako sun nam .class fajlovi u originalnom direktorijumu paketa postoje 2 opcije: Putanja do paketa se mora pojaviti u stringu kojim se postavlja CLASSPATH environment promenljiva. Koristiti –classpath opciju u komandnoj liniji kada se poziva kompajler ili interpreter. ako se odlučimo za Classpath promenljivu, ona treba da sadrži putanje samo do naših , ne i do standardnih paketa. -classpath primjer: MyProgram.java.
javac
.classpath”.;C:\MYsoruce;
C:\MyPackages”
„.“ Označava tekući direktorijum (potrebno je navesti i kod kompajliranja – inače – ćemo dobiti poruu da main() metod nije nađen.
Kontrola pristupa članovima Kontrola pristupa članovima klase izvan te klase , tj.iz metoda neke druge klase. Znamo da možemo referisati proizvoljan statički član klase, dok nestatički metod klase može referisati proizoljan član te klase. Što se tiče dostupnosti članova klase drugim klasama, stvari su malo komplikovanije. Tu u igru ulaze „pristupni atributi“.
Korišćenje pristupnih atributa i istih atributa za klasu Razmotrimo najpre klase koje se nalaze u istom paketu. Unutar datog paketa, svaka klasa ima direktan pristup imenima klasa istog paketa, za deklarisanje promenljivih i zadavnje tipova parametara metoda, ali atributi i metodi članovi te druge klase ne moraju nužno biti dostpuni. Njihova dostupnost kontroliše se pristupnim atributima. Strana | 30
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Imenu klase iz jednog paketa može se pristupiti iz klase drugog paketa, jedino ako je klasa kojoj se želi pristupiti deklarisana kao public. Klasama koje nisu deklarisane kao public može se pristupati samo iz klasa koje se nalaze u istom paketu. Postoje 4 mogućnosti: Bez pristupnog atributa . dopušten pristup iz metoda proizvoljne klase iz istog paketa. Public – dopušteno pristup iz metoda proizvoljne klase(ne nužno iz istog paketa), sve dok je klasa čiji je to član deklarisana kao public. Private – dostupan samo iz metoda unutar klase. Nikakav pristup izvan klase. Protected – dopušten pristup iz metoda proizvoljne klase istog paketa i iz proizvoljne potklase(ne nužno iz istog paketa). Odgovarajuća ključna reč (public , private , protected) se doda na početak deklaracije člana, radi lakšeg praćenja koda, dobro je grupisati deklaracije članove sa istim atributom.
Uobičajeni izbor pristupnih atributa Uobičajeno je da instance promenljive(nestatički atribut) budu private tako da im se ne može direktno pristupati, niti se mogu direktno menjati izvan klase. Jedini način da im se pristupi ili da se njihove vrijednosti promijene jeste pomoću metoda iste klase. Ukoliko je potrevno izvan te kase, to se postiže tzv.pristupnom (accesor) metodom klase. Najčešće , atributi u public klasi treba da budu private, a metodi koji će e pozivati izvan te klase public. Izuzeci: Za klase paketa koje nisu public, a time nisu dostupne izvan paketa , konvencija je dozvoliti drugim klasama paketa direktan pristup atributima. Metode klase koje če interno korititi samo drugi metodi iste klase treba definisati kao private. U klasam poput Math koja je samo kontejner za korisne funkcije i standardne vrednosti podataka, sve treba da bude public. Nakon uvođenja potklasa ,još neke stvari se moraju uzeti u obzir. Strana | 31
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Korišćenje ekstenzija Drugi način da učinimo svoje pakete dostupnim nakon što smo ih kompajlirali jeste korišćenjem ekstenzija. Ekstentije su .jar fajlovi smjšteni u direkotrijumu koji se kreirao prilkom instalacije JDK. Klase i paketi iz .jar arhive koje smo smjestili u ext direktorijum biće automatski dostupni pri kompajliranju Java programa. Kada kreiramo .jar fajl za paket moramo dodati.class fajlove zajedno sa strukturom direktorijuma koja odgovara imenu paketa. Ne možemo dodati samo .class fajlove arhivi. Primjer : želimo da arhiviramo paket Geometry. Pod predpostavkom da smo kompajlirali paket i da tekuči direkotrijum sadrži direktorijum paketa, arhiva se može kreirati sljedećom komantom: Jar cvf Gemotry.jar Geometry\*.clas Kreiraće arhivu Geometry.jar i u nju dodati sve .class fajlove iz direkotrijuma Geometry. Potrebno je još samo iskopirati ovu .jar arhivu u ext direktorijum i paket če postati dostupan svakom programu.
Dodavanje klasa iz paketa u program Ako su definisane sa ključnom rečju public, možemo dodati proizvoljnu ili sve klase imenovanog paketa kodu našeg programa korišćenjem import deklaracija. U programu zatim možemo referisati klase koje smo učinili dostupnim import deklaracijama samo navođenjem njihovih imena. Import deklaracije se navode na početku fajla. Import Geometry.Shapes3D.D*; Ukjlučuje sve klase paketa Geometry.Shapes3D. sada možemo referisati prouvoljnu public klasu iz paketa navođenjem samo njenog. imena. Obično je bolje importovati samo klase paketa koje naš kod koristi naprimjer za klasu Sphere Import Geometry.Shapes3D.Sphere; Unutar jednog paketa možemo davati imena klasama bez brige da li t aimena već postoje negdje izvan paketa. Java tretira ime paketa kao dio imena klase, zapravo kao njegov prefix. Strana | 32
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Importovanje satitčkih članova klase Mogu se importovati imena statičkih članova klase iz imenovanog paketa u naš program. Ti statički članovi se zatim mogu koristi prosto navođenjem njihovih nekvalifikovanih imena kao npr: Import static java.lang.Math.PI; ….. Return 4.0/3.0*PI Importovanje svih statičkih Import static java.lang .Math.*;
članova
klase
Math:
Bitno je zapamtiti da import statičkih članova klase nije moguć za klase koje se nalaze u default – bezimenom paketu. Paket mora imati IME!
Accesor metodi Primjer: Pubic getX(){ Return X;} Na ovaj način vrijednost atributa postaje svuda , ali se može menjati samo unutar klase, accesor metodi se obično zove get*().
Mutator metodi Tako se nazivaju metode koje dopuštaju mijenjanje vrijednosti private atributa. Njihova imena su obično obila set*(). Nova vrijednost atributa se prosleđuje kao argument. Npr: Public void setX(double inputX){ x=inputX;} Glavna prednost korišćenja mutator metoda jeste što je moguće vršiti provjeru nove vrijednosti i spriječiti pridruživanje nedogovarajućih vrijednosti atributima.
Strana | 33
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Wrapper klase za primitivne tipove Svaka od ovih klasa ima statički metod toString() za konvertovanje vrijednosti odgovarajućeg primitivnog tipa String objekat. Takođe postoji ne-statički toString() metod u svakoj klasi koji vraća String reprezentaciju objekta klase. Postoje i metode za konvertovanje iz String objekta u primitivni tip. Npr: statički parseIn()član klase Integer prihvata String reprezentaciju cijelog broja kao argument i vraća ekvivalentnu vrijednost tipa int. U slučaju da konverzija nije moguća , izbacuje se izuzetak tipa NumberFormatException. AUTOBOXING vrijednosti primitivnih tipova: Automatske konverzije iz primitivnog u odgovarajući klasni tip (vrši ih kompajer kada okolnosti to dopuštaju) UNOBOXING Kompajler će takođe raditi i inverzne konverzije (referencu na objekat wrapper klase primitivnog tipa u vrijednost koju on enkapsulira).
Nasljeđivaje Nasljeđivanje je veoma važan aspekt OOP-a kreiranje nove klase na osnovu već postojeće klase(standardne ili korisnički definisane klase). Taj process naziva se izvođenje. Nova klasa je izvedena klasa ili direktna podklasa klase iz koje je izvedena, dok se klase iz koje se vrši izvđenje naziva bazna klasa ili super klasa. Izvedena klasa može poslužiti kao bazna u daljem postupku izvođenja. Primjer: Class Pas{ \\\članovi klase Pas } Ova klasa može sadržati atribute ime i atribute rasa. Iz klase Pas možemo izvesti klasu Šarplaninac koja predstavlja pse koji pripadaju rasi Šarplaninaca. Izvedena klase ove bazne klase bila bi: Class Sarplaninac extends Pas{ \\\članovi klase Sarplaninac } Strana | 34
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Ključna riječ extends označava da je Pas bazna klasa za klasu Sarplaninac , pa će objeat klase Sarplaninac imati članove naslijeđenje od klase Pas, pored članova klase Sarplaninac koji se pojavljuje u definiciji te klase. Mehanizam nasljeđivanja dodaje sve karakteristike bazne klase, u ovome slučaju klasa Pas, karatkeristikama izvedene klase. Članovi izvedene klase definišu karakteristike koje razlikuju izvedenu od bazne klase, tako da se izvedena klasa može smatrati specifikacijom objekata koje su specijalizacije objekata bazne klase.
Nasljeđivanje klasa Objekat izvedene klase uvijek u sebi ima kompletan objekat bazne klase, sa svim atributima i metodama. Međutim to ne znači da su svi članovi definisani u baznoj klasi dostupni metodama specifičnim za izvedenu klasu. Naslijeđeni član bazne klase je onaj koji je dostupan unutar izvedene klase. Ako član bazne klase nije dostupan u izvedenoj klasi , on onda nije naslijđen član, al i dalje predstavlja dio objekata izvedene klase.
Naslijeđeni član Nasliješeni član je “pravi” član izvedene klase i dostupan je svim njenim metodama. Objekti izvedene klase sadržaće sve naslijeđene članove bazne klase – i attribute i metode , kao i članove specifične za izvedenu klasu. Objekat izvedene klase uvije u sebi sadrži kompletan objeat bazne klase, uključujući sve attribute i metode koji nisu naslijđeni.
Naslijeđivanje atributa Ako želimo da izvedemo klasu iz klase u drugome paketu , bazna klasa mora biti deklarisana kao public. Ako izvedena klasa nije u paketu bazne klase ne nasljeđuje se private i atributi definisani bez pristupnog atributa(nasljeđuju se public i protected)i bazna klasa mora biti deklarisana kao public. Ako su izvedene i bazne klase u istom paketu , nasljđuju se svi atributi osim private atributa(public, protected)i atributi bez pristupnih atributa.
Strana | 35
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Statički atributi klase Data pravila nasljeđivanja odnose se kao na nestatičke, tako i statičke članove klase. Private i Static atribut bazne klase neće biti naslijeđen u izvedenoj. Dok će protected i static atributi biti naslijeđeni i dijelit će ga svi objketi izvedene, kao i bazne klase.
Skrivanje atributa Upotreba ima članova izvedene klase uvijek se odnosi na član definisan kao dio te klase. Za referisanje naslijeđenog člana bazne klase , moramo ga kvalifikovati ključnom riječju supper, da ukažemo da je to što hoćemo član supper klase.
Skriveni atributi Atribut izvedene može imati isto ime kao i atribut bazne klase. To generalno nije preporučeno prilikom dizajniranja klase, ali je moguće. Kada se tako nešto desi, atribut bazne klase i dalje može biti naslijeđen , ali biće sakriven atributom izvedene klase koji ima isto ime. Mehanizam sakrivanja se primjenuje kad god postoje istoimeni atributi u baznoj i izvedenoj klasi, bez obzira na njihove tipove i pristupne atribute.
Naslijeđeni metodi – osim konstruktora Obični metodi (metodi koji nisu konstrukotri) bazne klase, nasljeđuju se u izvedenoj klasi na isti način kao atributi bazne klase. Metodi deklarisani kao private u baznoj klasi, ne nasljeđuju se. Metodi deklarisani bez pristupnog atributa nasljeđuju se samo ako je izvedena klasa u istome paketu kao bazna. Ostali se svi nasljeđuju.
Naslijeđeni metodi – konstrukotri Konstruktori se razlikuju od običnih metoda. Konstruktori bazne klase se nikad ne nasljeđuju, bez obzira na njihove pristupne atribute. Strana | 36
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Objekti izvedene klase Izvedena klasa je produžetak bazne klase. Nasljeđivanje se odnosi na to koji članovi bazne klase su dostupni u izvedenoj klasi, ne koji članovi bazne klase postoje u objektu izvedene klase. Objekat podklase sadrži sve članove originalne bazne klase, plus sve nove članove koje smo definisali u izvedenoj klasi. Čanovi bazne klase postoje svi u objektu izvedene klase, samo ne možemo pristupiti nekima od njih u metodama koje definišem u izvedenoj klasi. Činjenica da ne možemo prstupiti nekim članivima bazne klase, ne znači da su oni suvišni – oni predstavljaju ključne članove objekata naše izvedene klase. Objekat klase Sarplaninac ima sve atribute klase Pas koje ga čine objektom klase Pas, iako neki od njih nisu dostupni metodama šarplaniac. Naravno naslijeđeni metodi bazne klase mogu pristupiti svim članovima bazne klase, uključujući ih onima koji nisu naslijeđeni. Iako konstruktori bazne klase nisu naslijeđeni u izvedenoj klasi, oni se mogu pozvati da inicijalizuju članove bazne klase. Ako ne pozovemo konstrukotra bazne klase iz konstrukotra naše izvedene klase, kompajler će pokušati da uradi to za nas. Pošto objekat izvedene klase u sebi sadrži objekat bazne klase, dobar način za inicijalizovanje tog baznog dijela objekta izvedene klase je koršćenjem konstrukotra bazne klase.
Pozviv baznog konstrukotra Pozivanje baznog konstruktora iz konstrukotra izvedene klase. Kjučna riječ “super” kao ime metoda poziva konstruktor super klas(direktne bazne klase). Uvijek je potrebno pozivati odgovarajući konstruktor bazne klase u konstrukotrima izvedene klase. Poziv konstruktora bazne klase mora biti prva naredba u tijelu konstrukotra izvedene klase. Ukoliko to nije slučaj komapjler će ubaciti poziv podrazumijevanog konstrukotra bazne klase za nas: Super(); //poziv podrazumijevanog konstruktora bazne klase. Kada definišemo sopstveni konstruktor u klasi, kompajler ne kreira podrazumijevani konstrukotr jer predstavlja da mi brinemo o svim detaljima konstruisanja objekata uključujući i potrebu za podrazumijevanim konstruktorom. Ukoliko u baznoj klasi
Strana | 37
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
nismo definisali svoj podrazumijevani konstruktor, tj. Konstruktor bez parametara kada kompajler umetne poziv podrazumijevanog konstruktora , dobija se greška.
Predefinisanje (overriding) metoda bazne klase Može se definisati metod u izvedenoj klasi koji ima isti potipis kao i neki metod bazne klase. Pristupni atributi metoda u izvedenoj klasi može biti isti kao u baznoj klasi ili manje restriktivan, ali ne smije biti restriktivni. To znači da ako u baznoj klasi definišemo public metod, u svakoj izvedenoj klasi metod mora biti također deklarisan kao public. Kada se na taj način definiše metod, za objekat izvedene klase , a ne metod naslijeđene od bazne klase. Metod u izvedenoj klasi predefiniše metod bazne klase. Metod bazne klase je još uvijek tu, još uvijek je moguće pozvati ga u izvedenoj klasi. Primjer: Public String ispis(){ Return name + “,” + rasa;} Primijetimo i da to String () mora biti public. Za ispis atributa vrsta bazne klase, nije moguće referisati ga u izvedenoj klasi, pošto nije naslijeđen. Ali možemo pozivati baznu verziju ovog metoda pomoću ključne rijeli super. Ključnu riječ suepr koristimo za poziv bazne verzije metode ispis() koji je skirven verzijom istoimenog metoda izvedene klase. Istu notaciju koristimo i za referisanje atributa super klase koji su skriveni istoimenim atributima izvedene klase. Ispis() verzija bazne klase vraća String reprezentaciju za bazni dio objekta. U verziji izvedene klase, na to nadovežemo ekstra informacije o izvedenom dijelu objekta.
Izbor pristupnih atributa bazne klase Metode koje čine spoljni interfejs klase treba deklarisati kao public. Sve dok nema predefinišućih metoda definisanih u izvedenoj klasi, public metodi bazne klase biće naslijeđeni i potpuno dostupni kao dio spoljašnjeg interfejsa ka izedenoj klasi. Atribute ne treba definisati kao public, osim ako to nisu konstante opšte namjene. Ako očekujemo da će drugi koristiti naše klase kao bazne, one će biti sigurnije ako Strana | 38
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
su atributi private, a obezbijedimo public metode za pristup i manipulaciju njima, ako je to potrebno. Na taj način, mi kontrolišemo kako objekat izvedene klase može da utiče na članove bazne klase. Protected članove bazne klase treba koristiti u paketu u kome želimo neomeatni pristup podacima iz proizvoljne klase tog paketa, a izvan paketa slobdan pristup je ograničen na potklase. Izostavljanje pristuonog atributa za član klase čini ga direktno dopstupnim drugim klasama istog paketa, dok sprečava da bude naslijeđen u potklasi van paketa – efektivno, to je private kada se gleda iz drugog paketa.
Višestruk nasljeđivanje i interfejsi Interfejsi Interfejs je kolekcija konstanti i – ili apstraktnih metoda i najčešće sadrži samo metode. Interfejs definiše samo prototip metoda. U klasama koje implementiraju dati interfejs definše se tijelo metode. Metode u interfejsu su uvijek public i abastract, konstatnte uvijek public, static i final, i to se ne piše eksplicitno. Metode u interfejsu su po definiciji uvijek instance , tj. Ne mogu biti statičke. Interfejs se definiše kao i klasa, jedino se umjesto ključne riječi class koristi ključna riječ interfeace. Formalna korist interfejsa je da se definiše eksterna forma skupa metoda koja imaju određenu funkcionalnost. Svaki metod deklarsan unutar interfejsa mora da ima definiciju unutar klase koja implementira interfejs, ako želimo da kreiramo objekte te klase. Ukoliko se neki metod interfejsa ne definiše u klasi koja ga implementira, klasa mora biti deklarisana kao apsraktna. Pošto su metode u interfejsu po definiciji public, moramo koristiti ključnu riječ public kada ih definišemo u odgovarajućoj klasi (atribut pristupa ne smije biti manje restriktivan). Interefejsi omogućavaju da klase koje nisu povezane implementiraju skup zajedničkih klasa. U Javi, klasa može da naslijedi samo jednu klasu, ali može da implementira više interfejsa. Public class Klasa Implements Klasa1, Klasa2, Klasa3{….} Strana | 39
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Možemo definisati interfejse bazirane jedne na drugima koristeći ključnu riječ extends. Public interfeace Konverzija extdents KonverzioniFaktori{…..} Za razliku od klasa koje mogu da naslijede samo jednu klasu interfejs može da naslijedi proizvoljan broj drugih interfejsa, korišćenjem ključne riječi extends. Public interface NoviInt extends Int1,Int2{… ..} primjer višestrukog nasljeđivanja Interfejs NoviInt nasljeđuje sve metode i konstante koje su članice interfejsa Int1 i int2.
Deklarisanje interfejsa Deklaracija interfejsa započinje ključnom riječju interfeace, i sadrži samo konstante i apstraktne metode. Za razliku od klasa, svi članovi interfejsa moraju biti public i interfejsi ne mogu sadržati nikakvu specifikaciju metoda. Sve metode deklarisane u interfejsu su implicitno public abstract, dok su svi podaci implicitno public static final. U skladu sa specifikacijom Java jezika, ne navode se ključne riječi public, abstract i final pri deklaraciji metoda i podataka interfejsa. Public interfeace Primjer{ Tip metoda1(parametri); Tip metoda2(parametri); Tip metodaN(parametri); Tip prom1=vrijednosti1; Tip prom2=vrijednosti2; Tip promN=vrijednostiN; }
Strana | 40
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Korišćenje interfejsa Da bi koristili interfejs, mora se navesti da konkretna klasa implementira interfejs, i klasa mora da realizuje svaku metodu iz deklaracije interfejsa. Navođenje da klasa implementira interfejs se vrši pomoću ključne riječi implements praćene imenom interfejsa u deklaraciji klase, na primjer: public class ABC impelents DEF{………}. Klasa može implementirati proizvoljno mnogo interfejsa. U tom slučaju, imena interfejsa se razdvajaju zarezima u zaglavlju klase: Public class ABC implements inteferjs 1, interfejs2,.....{………..} Dakle, interfejs koji deklariše metode, definiše skup operaija, čime se postiže da objekti različitih klasa mogu da dijele skup operacija. Ne može se kreirati objekat interfejsnog tipa, ali se može deklarisati promenljiva interfejsnog tipa koja može da čuva referencu na objekat svakog od tipova koji implementiraju taj interfejs. To znači da se promenljiva može iskoristiti za polimorfan poziv metoda deklarsianih u interfejsu.
Proširivanje interfejsa Interfejsi se mogu proširivati. Jedan interfejs može da proširuje više drugih: Interfeace I extends BI1,BI2 { double i_method();} Sve metode i konstante baznih interfejsa su dio novog interfejsa. Višestruko izvođenje kod klasa: Klasa koja proširuje neku klasi i implementira neki interfejs. Klasa koja implementira više interfejsa.
Polimorfizam Polimorfizam ozačava mogućnost da se jedan isti poziv metoda ponaša različito u zavisnosti od tipa objekta na koji se metod primenjuje. Polimorfizam radi sa objektima izvedene klase. Polimorfizam je pojam vezan za nasljeđivanje. Omogućava da se objekti izvedeni iz zajedničke superklase, bilo direktno ili indirektne, procesuiraju kao da su u pitanju objekti superklase, što značajno pojednostavljuje programiranje. Objekat zna kako Strana | 41
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
da reaguje na poslatu poruku. Ovo je ključni koncept polimorizma – ista poruka, poslata mnoštvu različitih objekata, ima više formi rezultata. Zbog ove višeobličnosti rezultata, sam princip se naziva polimorfizam. Polimorfizam značajno pojednostavljuje dodavanje novih klasa postojećoj aplikaciji, uz minimum modifikaciju koda. Koji će metod biti pozvan, zavisi od tipa objekta nad kojim se metod poziva, a ne od tipa promenljive koja sadrži referencu na objekat. Polimofrizam se primjenjuje isključivo na metode, ne i na članice podatke. Za polimorfizam je neophodno sljedeće: Poziv metoda nad objektom izvedene klase vrši se preko promenljive bazne klase. Metod koji se poziva mora biti deklarisan u baznoj kasi. Metod koji se poziva mora biti definisan u izvedenoj klasi. Polimorfizam omogućava jednostavno procesiranje objekata koji imaju zajedničku superklasu, indirektnu ili direktnu. Kako procesirati objekte koji ne dijele zajedničku superklasu, tj.nemaju nikakve veze jedni sa drugim? Uzmimo, na primjer, program za obračunavanje troškova koji ima firma. Firma ima zaposlene, koji primaju platu, a ima i račune za nabavljenu robu. Što se tiće obračunavanja troškova, poželjno je da iznos plata i računa može dobiti uniformnim zapisom, a ne da vodimo računa o tipu svih objekata koji mogu biti uključeni u račun. U tom smilslu, ne može koristiti polimorfizam kako smo ga do sad koristili, jer objekti tipa Radnik i Račn najvjerovatnije nemaju ništa zajeničko.
Apsraktne klase Apstraktna klasa je klasa koja ima jedan ili više metoda koji su deklarisani a nisu definisani i nazivamo ih apsrtaktnim metodama. Deklaraija apstraktnog metoda prethodi ključna rijel absract i oni nemaju tijelo metoda. Postoje klase koje ne mogu imati instance, i takve klase se nazivaju apstraktnim. U hijerarhiji nasljeđivanja, ovakve klase se koriste isključivo kao superklase, pa se ponekad nazivaju i apsraktnim superklasama. Svrha apstrakte klase je da posluži kao superklasa drugim klasama, tj.da se iz nje izvedu druge klase koje bi dijelile zajenički dizajn. Izvedene klase, koje mogu imati svoje instance, se nazivaju konkretnim klasama. U tom smislu, apstraktne klase sz nepotpune, Strana | 42
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Potklase izvedene iz apstratkne klase, da bi mogle imati svojih instanci moraju implementirati svaku deklarisanu metodu(implentaciju nekih metoda se može naslijediti). Ako to ne urae, i same postaju apstraktne. Apstraktne klase specificiraju samo ono što je zajedničko svim izvedenim potklasama. U hijerarhiji nasleđivanja, apstraktne klase se mogu naći na nekoliko nivoa, apstraktne klase Oblik2D i Oblik3D mogu naslijediti apstraktnu klasu Oblik. Klasa se deklariše pomoću ključne riječi abstract. Apstraktna klasa obično sadrži jednu ili više apstraktnih metoda. Metoda se deklariše apstraktnom takođe pomoču ključne riječi abstract. Kao npr: Public abstract double povrsina(); Apstraktne metode se ne implementiraju. Ako klasa sadrži bar jednu apstraktnu metodu, ona se mora eksplicitno deklarisati kao abstract, čak iako ta klasa sadrži neke implementirane metode. Da bi potklasa apstraktne superklase bila konkretna, ina mora implementirati sve apstraktne metode naslijeđene iz superklase. U prvom redu definicije klase navodi se ključna riječ abstract, da bi se klasa deklarisala kao apsrtaktna. Apstraktni metod ne može biti private. Jer private metod ne može biti naslijeđen, a samim tim ni redefinisan u potklasi. Primjer: Public abstract class Zivotinja{ public abstract void zvuk();} Ovim smo klasu Zivotinja deklarisali kao apstraktnu, pošto sadrži apstraktni metod zvuk Metod zvuk() će uvijek biti predefinisan u izvedenim klasama. Ne može se instancirati objekat apstraktne klase ali je moguće deklaristai promenljivu tipa apstraktne klase. Zivotinja ljubimac = null; ova promenljiva se kasnije može koristiti da sačuva referencu na konkretan objekat izvedene klase.
Grafičko programiranje – Java Graphical User Interfeace – GUI – Grafički korisnički interfejs Osnovni elementi koji nam trebaju za kreiranje GUI-ja nalaze se u 2 paketa: java.awt i java.swing. Paket java.awt je u Javi 1.1 bio primarno skladište klasa za kreiranje GUIja(Abstratct Windowing Toolkit), ali mnoge od klasa koje ovaj paket definiše zamenjene su u Javi iz javax.swing. većina klasa paketa javax.swing koje definišu Strana | 43
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
GUI elemente, tzv. Swing komponente, obezbeđuju dosta unapređene alternative za komponente definisane klasama iz java.awt paketa. Kao npr: JButton klasa iz Javax.swing u odnosu na Button klasu iz java.awt. međutim, Swing klasw su izvedene i samim tim zavise od osnovnih klasa definisanih u java.awt paketu i to ne možemo ignorisati. Swing klase su dio opštijeg skupa, tzv. Java Foundation Classes (JFC)klasa za programiranje GUI-ja. JFC pored Swing klasa sadrži takođe i klase za 2F crtanje iz paketa java.awt.geom. Swing klase su fleksibilnije od odgovarajućih klasa iz paketa java.awt, poto su u potupnosti implementirane u Javi. Pošto Swing komponente „čista“ Java, nisu ograničene karakteristikama platforma na kojoj se izvršavaju. Pored dodatne funkcionalnosti i fleksibilnosti Swing komponenata, one imaju i tzv, pluggable look and feel svojstvo koje omogućava promjenu izgleda komponente. Možemo programsi izabrati za koju komponentu neku od standardnih ili kreirati sopstveni look and feel je olakšan dizajniranjem klasa na poseban način iliti Model View Controloer arhitekturom MVC. MVC nije od posebnog značaja za primjenu Swing klasa, ali jeste ako hoćemo da modifikujemo pluggable look and feel komponente.
Kreiranje prozora Osnovni prozot u Javi predstavljen je objektom klase Window, definisane u paketu java.awt. Klasa JFrame paketa javax.swing je mnogo korisnija za kreiranje prozora jer nudi obilje mogućnosti. Njene super klase:
Object Java.lang
Component-defniše
komponentu, entitet
koji se može prikazati.
Container-definiše
component koja može sadržati druge komponente
Strana | 44
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Windows Java.awt
Frame-defniše prozor sa title barom i okvirom
Javax.swing
JFrame-definiše
frame-to proširenim mogućnostima.
je
prozor
sa
Klasa Component definiše osnovna svojsta i metode za sve komponente. To je bazna klasa za sve Swing komponente. Klasa Container dodaje mogućnost Component objektu da sadrži druge komponente , što je dosta česta potreba. Pošto klasa JFrame ima Container za superklasu, JFrame objekat može sadržati druge komponente. Menu bar treba da sadrži menije npr.a toolbar dugmat itd. Iz tog razloga klasa container je takođe bazna za sve klase koje definšu Swing komponente. Klasa Window dodaje klasi Container metode specifične za prozor, poput rukovanja događajima koji nestaju interakcijom korisnika sa prozorom. Klasa JFrame dodaje klase Frame mnogo naprednijih mogućnosti za crtanje i prikaz drugih komponenti. Argument konstruktora definše naslov koji će biti prikazan u prozoru aplikacije. Main() metodo poziva 3 metode za objekat prozor. Metod SetBouns()definiše veličinu i poziciju prozora, prva 2 argumenta odgovaraju x i y koordinatama gornjeg levog ugla prozora aplikacije relativno u odnosu na gornji levi ugao ekrana, dok drugi par argumenata određuje širinu i visinu prozora u pikselima. Metod setVisible() sa argumentom true prikazuje prozor aplikacije preko svih prozora koji su trenuto vidljivi na ekranu. Oba ova Metoda i SetBounds i SetVisible us članovi klase JFrame a koji su naslijeđeni od klase Component,samim tim su i dostupni za svaku komponentu. Metod setDefaultCloseOperation()definisan je u klasi JFrame,pa je primenljiv samo za JFrame prozor objekte.
Strana | 45
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Komponente i kontejneri Komponenta predstavjla grafički entitet koji može biti prikazan na ekranu. Komponenta je svaki objekat klase koja je potklasa klase Component. JFrame prozor je komponenta, ali postoje i mnoge druge. JFrame – koristi se kao osnovni prozor aplikacije. Objekat ove klase ima title bar i mogućnost dodavanja menija i drugih komponenata. Nejčešće ćemo praviti potklasu ove klase kako bismo kreirali prozor specifičan za našu aplikaciju. JWindow – prozor bez title bar-a i ikona za upravljanje prozorima. Tipično se koristi kao pomoćni prozor aplikacije kada ima više displeja u sistemu. JDialog – za kreiranje dijalog prozora koji služi za unos podataka u program na različite načine. Obično kreiramo dijalog kao odgovr na izbor neke stake menija ili klika na dugme. JAplet – bazna klasa sa Java 2 aplet – program koji je napravljen da radi ugrađen u Web stranu. Moguće je crtati u JAplet, dodavati menije i druge komponente. JComponent – potklase ove klase definišu niz standardnih komponenti poput menija, dugmati , checkbox-ova itd. Koritimo h za kreiranje GUI-ja aplikacije ili apleta . Sve klase izvedene iz Container mogu sadržati druge objekte proizvoljnih klasa izvedenih iz Component. Pošto je klasa Container potkalse klase Component, svaki objekat kontejner je i Component takođe, pa kontejner može sadržati i druge kontejnere. Izuzetak su klasa Window i njene potklase, objekat tipa Window ne može biti sadržan u drugom kontejneru. Ako to pokušamo biće izbačen izuzetak. Klasa JComponent je bazna za sve Swing komponente korišćene u prozoru kao deo GUI-ja , pošto je ova kasa izvedena iz Container , sve Swing komponente su takođe kontejneri. Klasa JAplet koja je bazna za se Swing aplete , izvedena je iz Component preko klase Container, pa će time aplet naslijediti metode iz obe te klase. On takođe nasleđuje metode stare klase Applet koje dalje unapređuje. Klasa JAplet, JFrame , JDialog i JComponent se sve nalaze u paletu javax.swing. Applet je u java.applet, a sve ostale su u java.awt.
Strana | 46
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
Window i Frame komponente Osnovna razlika između JFrame i Window objekta je ta što JFrame objekat predstavlja glavni prozor aplijae, dok nam je za kreiranje Widnow objekta uvijek neophodno da predhodno imamo JFrame objekat. Pošto je klasa JDialog direktno izvedena iz klase Window, možemo kreirati JDIalog objekat u aplikaciji jedino u kontekstu JFrame objekta. Osim podrazumijevanog konstrukotra, konstrukotri klase JDialog generalno zahtijevaju JFrame objekat kao argument, i taj JFrame objeakat je roditelj JDialog objketa. JFrame objekat ima okvir, promenljive je veličine, može imati ugrađeni menu-bar. Pošto je JFrame objekat glavni prozor aplikaije,njegova veličina i pozicija definisane su relativno u odnosu na ekran. JDIalog objekat sa JFrame roditeljskim objektom biće smješten relativno u odnosu na roditelja. Dakle JAplet, JFrame, JDialog su sve kontejneri pošto sve imaju klasu Container za baznu, pa mogu sadržati komponente. One su takođe same po sebi komponente pošto su izvedene iz klase Component.
Prozorski okvir (Window Panes) Kada želimo da dodamo GUI komponente ili crtamo u prozoru priazanom JFrame objektom, mi dodajemo komponente ili crtamo u prozorski okvir rukovođen JFrame objektom. Prozorski okviri su kontejnerski objekti koji predstavljaju površinu prozora i ima ih više vrsta. Najveći dio vremena koristimo content pane. NAPOMENA! Postoji ogromna funkcionalnost u Javinim bibliotekama za podršku GUI. Sve to nemoguće je obuhvatiti jednom knjigom, Samo klasa JFrame sadrži preko 200 metoda uključujući one naslijeđene od superklasa. Bićemo jako selektivni u pogledu klasa koje ćemo upoznati i njihovih metoda, pokrićemo samo ono osnovno što nam je potrebno za kreiranje aplikacija i apleta.
JavaScript Javascript je novi skriptni jezik za koršćenje u programiranju www prezentacija. Uveden je od strane Netscape-a u Netscape Navigator, počevši od verzije 2.0 uporedo sa uvođenjem podrške za Javu. Brzo je postigao veliku popularnost i raširenost toliko da je i sam Microsoft pored uvođenja svog script Strana | 47
Objektno Orijentisano programiranje – Programski jeik Java
2014/2015 godine
jezika – Visual Basic Script, koji je kompaktibilan sa VB-om for aplication, uveo svoju verziju javascripta Jscript. Jedini razlog zašto Microsoft nije licencirao JS kao takav jeste što nije dobio licencu. Javascript se uključuje u sadržaj HTML dokumenta i omogućava unapređenje HTML strana sa interesantnim efektima. Naprimjer, korišćenjem Javascripta-a je moguće odgovoriti na akcije korisnika u samom www čitaču. Ono što je bitno zapamtiti jeste da je Java program može da se izvršava samo u okviru WWW čitača i nigdje drugdje. Najbolji način za upoznavanja sa jednim Internet orijentisanim jezikom kakav je Javascript je baš na Internetu.
Pozivanje unutar HTML dokumenta Cijeli program se smješta unutar HTML dokumenta unutar SCRIPT elementa. Atribut elementa SCRIPT je language, koji se tačno određuje o kome se SCRIPT jeziku radi. Danas postoje dva script jezika. Javascript i VisualBasic Script. Jednostavan Javascript Tekst prikazan na uobičajen način. Prmjer jednostavne Javascripte
<script language=”JavaScript”> document.write(“ tekst prikazan iz javascritpa.”)