Objektno orijentisano programiranje u PHP, Ispiti od Informatika

Preuzmite Objektno orijentisano programiranje u PHP i više Ispiti u PDF od Informatika samo na Docsity!

SKRIPTA IZ PREDMETA INTERNET TEHNOLOGIJE

Objektno orijentisano

programiranje u PHP

SADRŽAJ

• 1 UVOD.................................................................................................................
• 2 OOP u PHP........................................................................................................
• 2.1 Objekti.................................................................................................................
• 2.2 Klase...................................................................................................................
• 2.3 Atributi i modifikatori...........................................................................................
• 2.4 Metode i parametri..............................................................................................
• 2.5 Statičke metode..................................................................................................
• 2.6 Konkstruktori.......................................................................................................
• 2.7 Konstante............................................................................................................
• 2.8 Nasleđivanje.......................................................................................................
• 2.9 Prikrivanje metoda..............................................................................................
• 2.10 Abstraktne klase................................................................................................
• 2.11 Interfejs..............................................................................................................
• 2.12 this, parent i self.................................................................................................
• 2.13 Rukovanje izuzecima.........................................................................................
• 2.14 Korisne funkcije.................................................................................................
• 3 Primeri iz prakse.................................................................................................
• 3.1 ArrayList..............................................................................................................
• 3.2 Rukovanje tekstalnim fajlama.............................................................................
• 3.3 Rukovanje slikama..............................................................................................
• 3.4 Rukovanje bazom podataka...............................................................................

2.1. Objekti

Objekat može da bude sve. Sve što se piše u proceduralnom režimu, može da se premesti u objekat. Bilo koji entitet možete se predstaviti objektnom. Ukoliko vam je u programu neophodno da predstavite neku životinju, recimo psa, njega možete predstaviti objektom. Ukoliko želite da predstavite drvo, školu, ulicu,.... sve to možete predstaviti objektom.

Uzećemo jedan primer, recimo treba da prikažemo psa, i napravićemo jedan objekat (biće reči nešto kasnije o tome kako se kreira objekat) koji smeštamo u promenljivu $pas. Taj pas

ima neke karakteristike i neka ponašanja. Od karakteristika možemo da izdvojimo: dužinu dlake, boju dlake, visinu, dužinu ušiju, da li je pas ženka ili mužjak i tako dalje. Znači karakteristike opisuju životinju, tj. psa. U objektnom programiranju te karakteristike se nazivaju atributi ili polja. Znači objekat se sastoji od atributa/polja i oni opisuju stanje objekta.

Druga stvar koju možemo posmatrati je ponašanje psa ili neka radnja psa. To može da bude: hodanje, trčanje, lajanje, skakanje, ujed i tako dalje. Tako da pas pored svojih karakteristika ima i ponašanje. To ponašanje, prevedeno na OO jezik, predstavljaju metode. Znači dolazimo do zaključka da objekat ima atribute i metode. Atributi opisuju stanje objekta a metode opisuju radnju objekta. U OOP modu, to bi igledalo ovako:

$pas->boja_dlake = ’crna’; //postavljamo da pas ima crnu dlaku $pas->visina = 45; //postavljamo da je pas visok 45cm

$pas->lajanje(); // pozivamo metudu koja simulara lajanje psa $pas->trcanje(); //pozivamo metodu koja simuliranje trcanje psa

Kao što se vidi, objekti pozivaju atribute i metode tako što se prvo napiše promenljiva objekta ($pas), pa zatim se doda (->) i na kraju naziv metode ili naziv atributa. Sve ovo samo po

sebi i nema nekog smisla, neophodno je objasniti i šta su klase, kako se kreiraju objekti, kako se kreiraju atributi i metode i tek onda će slika o OOP biti nešto jasnija.

2.2. Klase

Klasu možemo shvatiti kao „fabriku“ za kreiranje objekata. Klase predstavljaju neku šemu ili šablon kako će se kreirati objekti i kako će oni izgledati. U klasi definišemo i atribute i metode objekta. Ona bi iz našeg primera izgledala ovako:

class Pas{

public $boja_dlake; public $visina;

function lajanje(){

function trcanje(){

Kao što se vidi, klase se kreira tako što se napiše ključna reč class i nakon toga dolazi proizvoljno ime klase, u našem slučaju pas. Nakon te deklaracije, otvara se vitičasta zagrada i na kraju i zatvara. Sve što se nalazi između vitičastih zagrada, predstavlja neku strukturu ili definiciju klase.

Atributi se definišu vrlo jednostavno, prvo se upotrebi ključna reč koja ukazuje na pristup i vidljivost atributa public (o tome nešto kasnije) i nakon nje, samo se naznače atributi kao obične promenljive $boja_dlake ili $visina, i tako je budućem objektu pridotata karakteristika koju on poseduje. Ponašanje objekta ili metode se definišu tako što se navede ključna reč function i nakon toga sledi naziv metode, obične zagrade pa vitišaste. U običnim zagradama se upisuju parametri (potpuno identično kao i kod obične funkciju u proceduralnom režimu) ili mogu da budu prazne, kao u našem slučaju, a između vitišastih se definiše ponašanje ili radnja koja treba da se izvrši nakon poziva te metode, i taj deo između vitičastih zagrada se naziva telo metode.

Dolazimo sada do pitanja, kako kreirati objekat uz pomoć klase. To je jako jednostavno i čini se na sledeći način:

$pas = new Pas();

Da bi se kreirao objekat, navodi se naziv objekta koji je proizvoljan, $pas, zatim sledi znak jednakosti, dolazi rezervisana reč new i na kraju naziv klase sa praznim zagradama (naravno, prazne su jer nema parametara, postoje primeri i kada se koriste parametri, ali o tome kasnije).

Ovo je najjednostavniji i osnovni primer kako se kreiraju klase i objekti i šta sadrže. Sada ćemo dati kompletan primer kako bi to izgledalo:

class Pas{

public $boja_dlake; public $visina;

function lajanje(){ echo 'avav avav'; } function trcanje(){ echo 'trcim trcim'; } }

$pas = new Pas(); $pas->boja_dlake = 'crna'; $pas->visina = 45; $pas->lajanje(); echo '
'; $pas->trcanje(); echo '
'; echo $pas->boja_dlake; echo '
'; echo $pas->visina;

class Pas{

public $boja_dlake; public $visina;

function lajanje(){ echo 'avav avav'; } function trcanje(){ echo 'trcim trcim'; } }

Ukoliko želimo da dodelimo nekom atributu neku vrednost to radimo na sledeći način:

$pas = new Pas(); $pas->boja_dlake = 'crna'; echo $pas->boja_dlake;

Na ekranu bi se pojavilo: crna

Prvo smo kreirali objekat $pas, a zatim pozvali atribut boja_dlake i dodelili joj crnu boju.

E sad, dolazi na red pitanje, čemu služi public. Sa public–om označavamo da je atribut javni i da može svako da mu pristupi. Tačnije, mi smo kreirali objekat $pas i direkto uz pomoć ->boja_dlake mu pristupili. Međutim, to u praksi i nije najbolje rešenje i uvek se

izbegava ta mogućnost. Mnogo je bolje i pametnije koristiti rezervisanu reč private. private ograničava pravo pristupa samo na klasu, i taj atribut možete pozvati samo iz klase, dok atribut označen kao public, možete pozvati i iz klase i van nje. Ovako bi to

izgledalo:

class Pas{

private $boja_dlake; private $visina;

function lajanje(){ echo 'avav avav'; } function trcanje(){ echo 'trcim trcim'; } }

$pas = new Pas(); $pas->boja_dlake = 'crna'; // GREŠKA !!!!!!!! echo $pas->boja_dlake;

Ovaj kod ne bi se izvršio jer pokušavamo da pristupimo atributu boja_dlake, a on je označen kao private. Onda se postavlja pitanje kako se pristupa tim atributima. To se radi

enkapsulacijom, kreiraju se get i set metode. To bi izgledalo ovako:

class Pas{

private $boja_dlake; private $visina;

function getBojaDlake(){ return $this->boja_dlake; } function setBojaDlake($bojaDlake){ $this->boja_dlake = $bojaDlake; } function lajanje(){ echo 'avav avav'; } function trcanje(){ echo 'trcim trcim'; } }

$pas = new Pas(); $pas->setBojaDlake('crna'); echo $pas->getBojaDlake();

Na ekranu bi se pojavilo: crna

Time smo zaštitili atribut od direktnog pristupa i omogućili da mu se pristupa preko set i get metoda. To se u programiranju naziva enkapsulacija. Preko metode set postavljamo vrednost, a preko metode get uzimamo vrednost (naredba return vraca vrednost i izlazi iz metode)

Postoji još jedan modifikator, a to je protected. On takođe ne dozvoljava da se pristupi izvan klase, ali za razliku od private, on dozvoljava pristup i nasleđenoj klasi (nešto kasnije o tom) dok private dozvoljava pristup samo u datoj klasi.

Da rezimiramo: Kada je neki atribut ili neka metoda privatna, tj. ispred naziva atributa i metode stoji private (uzmimo za primer atribut boja_dlake kod psa), to znači da atributu boja_dlake možete pristupiti SAMO i SAMO unutar date klase, tačnije iz tela klase. Svaki pokušaj pristupa tom atributu van klase predstavljao bi gresku. Telo klase predstavlja prostor između vitičastih zagrada

class Pas{ // telo klase }

pa prema tome, ovo bi nesumnjivo bila greška:

class Pas{ private $boja_dlake; }

$sluzba = new SSluzba(); $sluzba->proveraBodova(); $sluzba->upisUBazu(); $sluyba->upisUIndex();

Ovaj kod preveden u praksi bi značio: dolazimo na šalter i dajemo index. Zatim kažemo službenici da proveri broj bodova. Ona proverava i kaže da je uredu, nakon toga, kažemo joj da nas upiše u bazu, što ona i čini, i na kraju da nam sve to upiše i u index. Ona upisuje u index i vraća nam kroz šalter. Međutim, da li je u praksi baš tako, da li vi govorite šta službenica da radi ili ona sama zna svoj posao? Naravno da zna šta joj je činiti, zato mi i ne moramo da joj pričamo korake, već samo da joj damo index i kažemo da želimo da upišemo godinu, a ona sama obavlja taj posao. U tom slučaju, mi ne moramo da znamo da li će ona proveravati bodove, da li treba da nas upiše u bazu i ili možda treba još 10ak stvari da uradi. To nas ne zanima i to je njen posao. Naše je samo da kažemo da želimo da budemo upisani u novu školsku godinu i to je to. Onda bi to predstavili na ovaj način:

class SSluzba{

public upisiGodinu(){ $this->proveraBodova(); $this->upisUBazu(); $this->upisUIndex(); } private proveraBodova(){

} private upisUBazu(){

private upisUIndex(){

$sluzba = new SSluzba(); $sluzba-> upisiGodinu();

Obratite pažnju da su metode proveraBodova(), upisUBazu() i upisUIndex()

privatne i da niko ne može da im pristupi osim klase SSluzba. Mi sada možemo da pristupimo samo metodi upisiGodinu() i mi samo za tu metodu i znamo u praksi, a nemamo pojma šta službenica radi iza šaltera, to je njen posao. Kada pozovemo metodu upisiGodinu() ona poziva ostale tri metode koje su neophodne, a mi jednostavno o tome ne moramo da vodimo računa niti da znamo za njih, pa su iz tog razloga i obeležene kao private.

2.4. Metode i parametri

Do sada smo objasnili šta su metode. One predstavljaju ponašanje klase. U predhodom primeru set i get takođe predstavljaju metode (getBojaDlake(), setBojaDlake ($bojaDlake)), s tim da druga metoda ima jedan parametar $bojaDlake. Preko

parametra metodi prosledjujemo neku vrednost, zatim se ta vrednost obradi i rezultat vrati. U predhodnom primeru, ovaj parametar je služio samo da bi atributu $boja_dlake u kalsi Pas dodelili vrednost. Evo primera kako metoda prima parametre i sabira ih i vraća rezultat:

class Matematika{

function saberi($broj1, $broj2){ $zbir = $broj1 + $broj2; return $zbir; } }

$mat = new Matematika(); $rezultat = "Zbir je ".$mat->saberi(3,7); echo $rezultat;

Kao što se vidi, metode potpuno na isti način funkcionišu kao i funkcije u proceduralnom programiranju, samo što se pozivaju preko objekta, u ovom slučaju preko $mat.

2.5. Statičke metode

Metode mogu biti i statičke. To znači da nisu vezane za konkretni objekat, već se pozivaju preko klase. Tačnije, ne mora biti kreiran objekat da bi ste pozvali metodu, već to možetu uraditi direktno preko imena klase. To bi izgledalo ovako:

class Matematika{

static function saberi($broj1, $broj2){ $zbir = $broj1 + $broj2; return $zbir; } }

$rezultat = "Zbir je ". Matematika::saberi(3,7); echo $rezultat;

Ponekad su statičke metode korisnije, i upotrebljavaju se onda kada nije neophodno da se kreira objekat, već kada je logičnije da metoda bude vezana za jednu klasu.

Metode kao i atributi mogu imati modifikatore i vladaju potpuno ista pravila kao i za atribute. Oni se dodaju prvi, ispred function i static (ako je metoda staticka)

2.6. Konkstruktori

private $boja_dlake; private $visina;

public function __construct(){ $this->boja_dlake = 'crna'; $this->visina = 45; }

function lajanje(){ echo 'avav avav'; } function trcanje(){ echo 'trcim trcim'; } }

To znači, da ukoliko napišete $pas = new Pas(); , tada će i atributi biti inicijalizovani i

bice im dodeljena vrednost. Onda nije neophodno setovati te atribute naknadno preko set metode, jedino ako hoćete da promenite te vrednosti.

S obzirom da je konstruktor metoda, i on može imati parametre. Konstruktor možemo napisati i ovako:

public function __construct($bojaDlake, $visina){ $this->boja_dlake = $bojaDlake; $this->visina = $visina; }

U tom slučaju bi objekat kreirali na ovaj način:

$pas = new Pas('crna', 45);

2.7. Konstante

Klasa može sadržati i konstante, koje nisu vezane za objekte, već samo za klasu. Tako, klasa Matematika, bi mogla imati konstantu pi. Ona je ne zavisna od bilo kog objekta i bilo koje matematičke funkcije i uvek je 3.14. One se predstavljaju tako što se ispre naziva konstante doda ključna reč const. Uglavno se pišu velikim slovima, to je neko ne pisano pravilo, radi lakšeg snalaženja programera. Primer:

class Matematika{

const PI = 3.14;

static function pomnoziSaPI($broj1){ $proizvod = $broj1 * self::PI;

return $proizvod; } }

Konstante se izvan klase pozivaju preko naziva klase Matematika::PI, a u samoj klasi preko ključne reči self, na ovaj način self::PI

2.8. Nasleđivanje

Dolazimo do dela gde objektno orijentisano programiranje dobija puno na značaju. Do sada je bilo reči o osnovim pojmovima u klasama i objektima, a sada dolaze najznačajniji delovi OOP-a.

Šta je zapravo nasleđivanje? Svaka klasa sadrži određene atribute i metode preko kojih se opisuje stanje i ponašanje iste. Zamislimo da u programu kreiramo dve klase, od kojih obe sadrže dobar deo istog koda. Tačnije, sadrže nekoliko zajedničkih promenljivih i zajedničkih metoda, koje moraju da budu identične. Recimo, hoćemo da kreiramo klasu Pas i klasu Mačka. Obe klase predstavljaju životinje, i obe klase imaju neke zajedničke osobine kao što su: visina, težina, hodanje, trčanje i tako dalje. Ali pored zajedničkih osobina, postoje i one specifične. Recimo pas lovi mačke, dok mačka lovi miša, pas laje a mačka mjauče i tako dalje.

Analogno tome, imamo dve klase:

class Pas{

private $tezina; private $visina; private $brojUhvacenihMacaka;

public function __construct($tezina, $visina, $brojUhvacenihMacaka){

$this->tezina = $tezina; $this->visina = $visina; $this->brojUhvacenihMacaka = $brojUhvacenihMacaka; }

function trcanje(){ echo 'trcim trcim'; } function uloviMacku(){ echo $this->brojUhvacenihMacaka += 1; } }

class Macka{

private $tezina; private $visina;

funkcionalnost klase Zivotnja. Ono sto ćemo morati da uradimo, to je da nasledimo klasu Zivotinja. Nasleđivanje se čini pomoću ključne reči extends

class Pas extends Zivotinja{

private $brojUhvacenihMacaka;

public function __construct($tezina, $visina, $brojUhvacenihMacaka){

parent::__construct($tezina, $visina); $this->brojUhvacenihMacaka = $brojUhvacenihMacaka; } function uloviMacku(){ echo $this->brojUhvacenihMacaka += 1; } }

Kao što se vidi, iz klase Pas su izbačne sve metode i atributi koji postoje u klasi Zivotinja, jer ih klasa Pas sve nasleđuje. Novina u ovoj klasi je ta, da konstruktor prima idalje parametre $tezina i $visina, a tih parametara nemamo u datoj klasi. Tako je, oni ne postoje u nasleđenoj klasi (Pas), ali postoje u roditeljskoj klasi (Zivotinja). Kada smo primili te parametre, neophodno je pozvati nadređeni konstruktor, tj. roditeljski konstruktor i proslediti im date parametre. To se čini pomoću ključne reči parent. Ta ključan reč može da se upotrebi bilo za pozivanje konstruktora bilo za pozivanje metoda nadređene klase.

VAŽNO!

Nadređeni konkstruktori u PHP-u se ne pozivaju automatski kao što je kod JAVE i C# slučaj, već mora se pozvati neposredno korišćenjem ključen reči parent.

Klasa Mačka bi izgledala ovako:

class Macka extends Zivotinja{

private $brojUhvacenihMiseva;

public function __construct($tezina, $visina, $brojUhvacenihMiseva){

parent::__construct($tezina, $visina); $this->brojUhvacenihMacaka = $brojUhvacenihMiseva; } function uloviMisa(){ echo $this->brojUhvacenihMiseva += 1; } }

Iz ovog primera se vidi da smo zajedničke podatke podigli na viši (abstraktniji) nivo, a specifičene spustili na niži (specifičniji) nivo. Sada više nema dupliranja koda i ovim smo skratili vreme razvoja, preglednosti i smaljili mogućnost grešaka u daljem projektovanju.

Šta biva ako nam sada u klasi Pas zatreba njegova tezina? Recimo hoćemo da implementiramo metodu da na monitoru ispiše koliko se pas ugojio, tačnije koliko trenutno ima kilograma, ako mu se od svake ulovljenje mačke poveća težina za 100 gr. To bi izgledalo ovako:

class Pas extends Zivotinja{

private $brojUhvacenihMacaka;

public function __construct($tezina, $visina, $brojUhvacenihMacaka){

parent::__construct($tezina, $visina); $this->brojUhvacenihMacaka = $brojUhvacenihMacaka; } function uloviMacku(){ echo $this->brojUhvacenihMacaka += 1; } function povecajTezinu(){ $povecanjeTezine = $this->brojUhvacenihMacaka * 0.1; $novaTezina = $this->tezina + $povecanjeTezine; echo $novaTezina; }

Prva linija koda u metodi povecajTezinu() računa vrednost koliko se ukupno pas nagojio od mačaka ako je za svako ulovljenu mačku dobio po 100gr. Druga linija koda, tu vrednost sabira sa trenutnom težinom psa, a treća linija koda prikazuje rezultat. Isprobajmo da vidimo kako radi:

$pas = new Pas(25, 35, 2); $pas->povecajTezinu();

Kreiramo objekat pas sa težinom od 25kg, visinom 35kg i sa 2 ulovljene mačke. Prema našim proračunima, nakon izvršavanja ovog koda, rezultat bi bio

Međutim, nakon izvršavanja koda, vidimo da je rezultat 0.2. Krenimo redom da analiziramo kod:

$povecanjeTezine = $this->brojUhvacenihMacaka * 0.1; naš slučaj: $povecanjeTezine = 2 * 0.1; vrednost: $povecanjeTezine = 0.2;

$novaTezina = $this->tezina + $povecanjeTezine; naš slučaj: $novaTezina = 25 + 0.2;

vrednost: $novaTezina = 25.2;

function trcanje(){ echo 'trcim trcim'; } function uloviHranu(){ echo 'lovim hranu'; }

}

class Pas extends Zivotinja{

private $brojUhvacenihMacaka;

public function __construct($tezina, $visina, $brojUhvacenihMacaka){

parent::__construct($tezina, $visina); $this->brojUhvacenihMacaka = $brojUhvacenihMacaka; } }

Ukoliko kreiramo objekat klase Pas i pozovemo metodu uloviHranu() , na ekranu će se prikazati lovim hranu(možemo da pozovemo tu metodu jer je ona definisana u klasi

Zivotinja, pa kako je klasa Pas nasleđuje, onda je sve regularno). Međutim, mi ne želimo da se to prikaže jer znamo šta pas lovi, i hoćemo da se na ekranu prikaže lovim mačke. To ćemo uraditi tako što ćemo dodati tu metodu u klasi Pas. To bi igledalo ovako:

class Pas extends Zivotinja{

private $brojUhvacenihMacaka;

public function __construct($tezina, $visina, $brojUhvacenihMacaka){

parent::__construct($tezina, $visina); $this->brojUhvacenihMacaka = $brojUhvacenihMacaka; } function uloviHranu(){ echo 'lovim mačke'; } }

Sada ako kreiramo objekat klase Pas i pozovemo metodu uloviHranu() , na ekranu će pisati lovim mačke. Možda je sada nedoumica oko toga, koju će metodu pozvati, metodu

uloviHranu() u klasi Zivotinja ili u klasi Pas. Prilikom odabira metode, uvek se prvo gleda metoda koja se nalazi u instanciranoj klasi, tačnije u klasi iz koje je kreiran objekat. Kako je naš objekat instanca klase Pas, prvo će se izvršiti metoda u toj klasa, pa ako metoda ne postoji u toj klasi (kao u malopređašnjem slučaju), onda se poziva roditeljska metoda. Ovaj sistem se zove prikrivanje metoda.

To je dosta korisno i vrlo često se primenjuje u programiranju. U našem slučaju bi bilo korisno ukoliko bi smo želeli da kreiramo klasu neke životinje, a da ne znamo čime se ona hrani. Jednostavno ne bi u toj novoj klasi dodali metodu uloviHranu(), tj. ne bi prikrili roditeljsku metodu, i uvek kada bi je iz programa pozvali, pisalo bi „lovim hranu“.

2.10. Abstraktne klase

Pogledajmo predhodni primer

class Zivotinja{

private $tezina; private $visina;

public function __construct($tezina, $visina){ $this->tezina = $tezina; $this->visina = $visina; }

function trcanje(){ echo 'trcim trcim'; } function uloviHranu(){ echo 'lovim hranu'; }

Ukoliko dobijemo zahtev da SVE klase koje nasleđuju klasu Zivorinja moraju da reimplementiraju metodu uloviHranu() (tačnije da dodaju tu metodu u svoju klasu), onda se postavlja pitanje, šta će nam ta metoda u roditeljskoj klasi ako nikada neće biti izvršena. Tačnije, ako za svaku životinju znamo čime se hrani, onda nam ova generalna metoda i nije potrebna. Ono što nama treba sada u roditeljskoj klasi je samo potpis metode (u potpis metode spada modifikator, rezervisana reč function, ime metode i parametri koje ona prima), ali ne i telo. To možemo napisati ovako:

function uloviHranu();

Ova linija koda je pogrešna, jer posle naziva metode i parametara koje prima, očekuju se vitičaste zagrade i telo metode. Da bi ovo rešili, možemo da napišemo ovako:

abstract function uloviHranu();

ovo je sada ok. Sada smo metodu uloviHranu() označili kao abstraktnu, a to znači da ima sve kao i obična metoda osim tela. Ispred function stoji i ključna reč abstract kako bi pokazala da je metoda abstraktna i da nema telo. Do sada je sve kako treba, međutim, idalje postoji problem. Obične klase ne mogu sadržati abstraktne metode. Da bi i ovo rešili, moramo i klasu proglasiti abstraktnom tako što ćemo ispred ključne reči class dodati abstract. To bi izgledalo ovako

abstract class Zivotinja{