PROGRAMARE ORIETATA OBIECT

OOP este doar o extensie a urmatorului concept:

Un site in general cuprinde un meniu n partea de sus a fiecrei pagini web, iar
acest meniu este identic in tot site-ul
=> se poate realiza codul intr-o sg pagina iar in toate celalalte pagini va fi
introdus cu copy si paste => o actiune contraproductiva.
Conform ergonomiei este important ca un cod sursa sa se scrie o sg data si
sa fie apelat de fiecare data cand este nevoie de el.
Plecand de la aceasta idee plus ca server side iti da dreptul sa modifici
intr-un singur loc si sa se vada peste tot fara sa se descarce fisierul de pe
server am putea rezuma aceast abordare ca fiind "includ i refolosesc nu
rescriu."
Deci, intr-un sens, programarea orientat pe obiecte (OOP), este doar o
extensie a acestui concept.
OOP este un tip de programare ce a fost adaugat in php5.
Acest tip de programare permite dezvoltarea de aplicatii web complexe,
modulare si reutilizabile.
PHP5 a permis ca php sa poata fi pus pe acelasi nivel cu JAVA si C#.

Programarea oop in PHP, impune cunoasterea urmatoarele elemente de baza PHP:

Functii, variabile, cicluri si instructiuni conditionale.
Pas1: Crearea a 2 pagini: Index.php si class_lib.php
OOP este legat de crearea unui cod modular, a.i. codurile PHP orientate pe obiecte vor fi
introduse in fisiere predestinate lor pe care ulterior le vom insera intr-o pagina PHP normala
folosind include.
Exempl: codul orientat obiect va fi retinut in fisierul PHP: class_lib.php

OOP se invarte in jurul actiunii de construire a unei class. Clasele sunt:

cookie-cutters/templates care sunt folosite pentru a define obiecte.
Pas2.Crearea unei clase PHP
In loc de a crea o gramada de functii, variabile si instructiuni pentru a implementa scripturi php,
OOP ofera posibilitatea de a crea clase.
O clasa: se defineste incepand cu cuvantul rezervat class urmat de numele pe care
utilizatorul/programatorul il doreste pt aceea clasa.
Exemplu:
<?php
class persoana{
}
?>

Pas 3: Se adauga date in clasa definite la pasul 2.

Calsele sunt proiectate pentru obiectele php.
Una din cele mai mari diferente intre functii si clase este:
O clasa contine atat date (variabile) + functii care impreuna formeaza obiectul.
O clasa este de fapt o structura care contine:
Variabile (membrii sau proprietati)- descriu membrii clasei
Functii (metode): metodele sunt operatiile pe care membrii clasei le pot efectua.
Functiile(=METODE) contin variabile(date) si instructiuni.
Cand se creaza o variabila in interiorul unei clase aceasta se numeste proprietate

<?php
class persoana {
var $nume;
}
?>
Obs:Variabilele/datele din interiorul unei clase se numesc proprietati deci in exemplul de mai sus
proprietatea clasei persoana este var $nume

Pas 4:Adaugarea functiilor/metodelor unei clase

Deci, variabilele care se folosesc/definesc in ineriorul unei
clase nu se mai numesc variabile ci proprietati.
n acelai mod funciile care se definesc in interiorul unei
clase acestea sunt denumite "metode".
Metodele unei clase sunt folosite pentru a manipula
proprietile (variabilele).
Deci, functiile in OOP =metode ale obiectelor.
<?php
class persoana {
var nume;
function set_nume($new_nume) {
//primeste numele
$this->nume=$new_nume}
function get_nume() { //afiseaza numele
return $this->nume;
}
}
?>

Pas 5:
Functia constructor (setter)-preia valorile trimise din programul
principal.
Functia de afisare(getter)-livreaza valorile stocate in variabile

Am creat dou funcii / metode: get_nume () i set_nume ().

Aceste metode respecta o conventie specifica programarii OOP
intalnita in multe alte limbaje cum ar fi Java, C, Ruby unde se creaza
metodele set si get pentru proprietatile unei clase.
O alt regula/conventie (o convenie de denumire) -numele functie get
si set trebuie s se potriveasc cu numele proprietilor.
Obs: Se observa c numele getter si setter, se potrivesc cu numele
proprietii asociata. n acest fel, atunci cnd ali programatori PHP
doresc s utilizeze un obiect definit prin aceasta tehnica regula este:
dac exista o metoda / functie numita "set_nume ()", va exista o
proprietate / variabil numit "nume".

Pas6. Variabia $this

-este o variabila incorporata in toate obiectele care indica obiectul
curent.
- Cu ale cuvinte este o variabila speciala de auto-referinta.
-se foloseste pentru
- a accesa proprietatile si
-apela metodele clasei curente.
Ex:
funcion get_nume(){
return $this->nume;}

Pas 7: Includerea clasei intr-o pagina principala PHP.

Principiul OOP: In pagina principala PHP nu se creaza clase.

Conform OOP este bine sa se creeze pagini separate care contin
clasele.
Paginile in care se definesc clasele sunt incluse in pagina principala cu
include sau require.
Ex: Pagina principala in care se include pagina class_lib.php in care se va
defini clasa.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>OOP in PHP</title>
<?php include("class_lib.php"); ?>
</head>
<body>
</body>
</html>

Pas 8. Instantierea/crearea obiectului

Clasele sunt proiectele/template-urile obiectelor php.
Clasele nu au obiecte inainte de instatiere.
La initializarea unei clase, se creaza o instanta a acesteia, creandu-se
astfel obiecte.
Cu alte cuvinte, instantierea este procesul de creare in memoria
serverului a unui obiect.
<!DOCTYPE
html
PUBLIC
"-//W3C//DTD
XHTML
1.0
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>OOP in PHP</title>
<?php include("class_lib.php"); ?>
</head>
<body>
$stefan = new persoana();
</body> </html

Transitional//EN"

Obs: variabila $stefan devine un handle/trimitere la clasa care creaza obiectul

persoana.
Handler, pt ca se folosete $stefan pentru a controla si utiliza obiectul persoana.
Daca se ruleaza codul PHP acum, nu se vede nimic afiat in browser. Motivul pentru
acest lucru, este => nu s-a precizat PHP ului ce sa faca cu obiectul tocmai creat.

Pas 9: Cuvantul new

-se foloseste at cand se creaza obiectele unei clase.
La crearea/ instatierea unei clase se pot adauga optional paranteze la
numele clasei.
Din punctul de vedere a motorului PHP, fiecare obiect este o entitate
proprie.
<?php include("class_lib.php"); ?>
</head>
<body>
$stefan = new persoana();
$ion= new persoana;
</body>
</html>

Obs: nu se pun ghilimele sau apostroafe la crearea unui obiect ca de ex:

$stefan = new 'persoana'; genereaza eroare.

Pas 10: Setarea proprietatilor pentru un obiect.

La pas 9 s-au creat/instantiat 2 obiecte persoana, pentru acestea se pot
sa se seteze proprietatile lor folosind metodele de tip set care s-au
creat in class.
OBS: S-au creat 2 obiecte persoana
$stefan si $ion care se baseaza pe aceeasi clasa persoana,
cu toate ca php le considera 2 obiecte complet diferite.
<php include ("class_lib.php");?>
</ head>
<body>
<? Php
// se creaza obiectele $stefan si $ion
$stefan = new persoana ();
$ion = new persoana;
//se foloseste metoda set din clasa pt a atribui valori
$stefan-> set_nume ("Stefan Mischook");
$ion-> set_nume (IonWaddles");
?>
</ body>
</ html>

Pas 11: Accesarea datelor unui obiect

-se folosesc metodele get pentru a se accesa datele retinute in
obiectele create.
Aceste date s-au inserat cu metodele set in obiecte la pasul anterior.
At cand se acceseaza metodele si proprietatile unei clasese foloseste
operatorul ->
<?php include("class_lib.php"); ?>
</head>
<body>
<?php
$stefan = new persoana();
$jimmy = new persoana;
$stefan->set_nume("Stefan Mischook");
$ion>set_nume(Ion Waddles");
echo "Numele intreg a lui Stefan: " . $stefan->get_nume();
echo " Numele intreg a lui Ion: " . $ion->get_nume();
?>
</body>
</html>

Pas 12: Accesarea directa a proprietatilor-nu este indicata

Pt a realiza accesarea directa a proprietatilor este nevoie
1. de operatorul ->
2. de numele variabilelor,
nu este nevoie de metode !!!!!!!!!!
Ex: cu proprietatea $nume (in obiectul $stefan) se poate determina
valoarea acestuia astfel: $stefan->nume.
Aceasta practica este considerata gresita deoarece poate genera erori
pe parcursul programarii.
Se recomand => sa se utilizeze metoda getter.
<?php include("class_lib.php"); ?>
</head> <body>
<?php
$stefan = new persoana();
$ion = new persoana;
$stefan->set_nume("Stefan Mischook");
$ion->set_nume(Ion Waddles");

// accesul direct a proprietatilor unei clase este un NU-NU.

echo "Nume intreg a lui Stefan: " . $stefan->nume;
?></body> </html>

Pas 13: Constructori

Toate obiectele trebuie sa detina o metoda speciala numita constructor.
Constructorii au ca rol initializarea proprietatilor obiectelor
(traducere: dati valori proprietatilor) at cand se creaza/instatiaza un obiect.
Obs:
Daca se creaza o functie __construct() PHP va apela in mod automat metoda/functia
__construct() at cand se creaza un obiect al clasei.
Metoda construct: -incepe cu 2 liniute de subliniere in fata cuvantului construct.
-va avea in fata cuvantul function si se termina cu paranteze in
interiorul carora se afla 1 sau mai multi parametrii.
Ex: <?php
class persoana {
var $nume;
function __construct($persoana_nume) {
$this->nume = $persoana_nume;
}
function set_nume($new_nume) {
$this->nume = $new_nume;
}
function get_nume() {
return $this->nume;
} } ?>

Obs:
In cele ce urmeaza trebuie sa se retina
urmatoarele:
Functii=metode
Variabile=proprietati
Pt ca aceasta este terminologia programarii
OOP.

Pas 14: Crearea unui obiect cu un constructor

-daca in program se creaza metoda constructor se poate atribui o
valoare proprietatii $nume at cand se creaza obiectele persoana.
Ex:
$stefan=new persoana(Stefan Miscoo);
Aceasta elimina apelul metodei set_nume() ceea ce are rolul de a
reduce cantitatea de cod.
Constructorii se folosesc frecvent in PHP si Java.
<?php include("class_lib.php"); ?>
</head>
<body>
<?php
$stefan = new persoana("Stefan Mischook");
echo "Numele intreg " . $stefan->get_nume();
?>
</body>
</html>

Pas 15: Restrictionarea accesului la proprietati

-se face folosind modificatori de acces. Unul din principiile de baza
OOP este incapsularea.

Ideea este ca se creaza un cod mai curat, daca se reduce accesul la

structurile de date (proprietatile) ale obiectelor.
Rolul modificatorilor de acces este de a restrictiona accesul la
proprietatile clasei.
Exista 3 modificatori de acces
1. public(public)
2.private(privat)
3. protected(protejat)

Modificatorul implicit este:public

Obs: cand o proprietate se declara cu cuvantul cheie var at aceasta
este considerata implicit publica.
<?php
class persoane {
var $nume;
public $height;
protected $social_insurance;
private $pinn_number;
function __construct($persoane_nume) {
$this->nume = $persoane_name; }
function set_nume($new_nume) {
$this->nume = $new_nume;
}
function get_nume() {
return $this->nume;
} } ?>

Pas 16: Partea 2 acces restrictionat

At cand se declara o proprietate ca private, proprietate se poate accesa numai
din aceeasi clasa.
Cand o proprietate este declarata protected proprietatea poate fi accesata
numai din aceeasi clasa sau din clasele derivate din aceasta.
Propritatea declarata ca public nu are restrictii de acces, ceea ce inseamna ca
oricine le poate accesa.
<?php include("class_lib.php"); ?>
</head> <body>
<?php
$stefan = new persoana("Stefan Mischook");
echo "Numele intreg a lui Stefan: " . $stefan->get_nume();
/* Din moment ce $ pinn_number a fost declarat privat, aceast linie de cod va genera o eroare. * /
echo "Spune lucruri private: " . $stefan->$pinn_number;
?>
</body>
</html>

Motivul pentru folosirea modificatori de acces se reduce la control:

se detine controlul asupra modului in care oamenii au acces la clase .

Exista multe constructii OOP, din ideea ca muli programatori pot lucra la un proiect ...

Obs: pt ca metoda get_pinn_number() este 'private' singurul loc in care

se foloseste aceasta metoda este in aceeasi clasa- in general in alta
metoda.
Daca se doreste sa se foloseasca acesta metoda direct in paginile PHP at
trebuie declarata public
<?php
class persoane {
var $nume;
public $height;
protected $social_insurance;
private $pinn_number;
function __construct($persoane_nume) {
$this->name = $persoane_nume;
}
private function get_pinn_number() {
return $this->$pinn_number;
}}
?>

Pas 18: Modul de refolosire a codului OOP: mostenirea

Mostenirea (Inheritance) este o capacitate/constructie fundamentala in OOP,
in care se poate folosi o sg clasa ca si clasa de baza pentru o alta clasa/clase.
Obs: Facand acest lucru se poate reutiliza eficient codul din clasa de baza. Daca se
doreste sa se creeze o alta calsa de angajati, pt ca angajatii sunt un tip de peroane care
prezinta proprietati si metode comune.
In astfel de situatii mostenirea(inheritance) poate refolosi acelasi cod in 2 clase diferite.
Fata de programarea procedurala in PHP OOP:
1. codul se introduce o sg data
2. codul creat poate fi refolosit nelimitat ... conceptual aceasta idee este echivalentul
lui include din PHP.

Sa luam un exemplu:
//extends este cheia pentru a permite mostenirea.
class angajati extends persoane {
function __construct($angajati_name) {
}
}

Pas 19:Reutilizarea codului folosind mostenirea (inheritance) partea2

Deoarece clasa angajati se bazeaza pe clasa persoana, aceasta
automat va avea metodele si proprietatile atat public cat si protected
ale clasei persoana.
Obs: deci se poate spune ca angajati este un tip de peroana.
Codul care permite mostenirea este:
class angajati extends persoane {
function __construct($angajati_nume) {
$this->set_nume($angajati_nume);
}}

Obs: Modul in care in clasa angajati se foloseste metoda set_nume()

care a fost declarata in clasa persoana deci nu mai trebuie declarata
in clasa angajati.
Clasa persoana se numeste clasa de baza sau parinte pt ca este clasa
pe care se bazeaza clasa angajati care se numeste clasa copil. Aceasta
ierarhie de clase este importanta in proiecte de dimensiuni mari.

Pas 20: Reutilizarea codului prin mostenire: partea 3

Se poate apela functia get_name ce apatine clasei persoana pentru
obiectul angajati.
Acesta este un exemplu clasic pentru programarea OOP avand drept
scop reducerea numrului de linii de cod (nu trebuie s scrie aceleai
metode de dou ori), si cu toate acestea se pstreaza codul modular care
este mult mai usor de intretinut.
<title>OOP in PHP</title>
<?php include("class_lib.php"); ?>
</head>
<body>
<?php
// exemplu de utilizare a obiectelor PHP
$stefan = new persoane("Stefan Mischook");
echo "Numele intreg a lui Stefan: " . $stefan->get_nume();
$james = new angajati("Johnny Fingers");
echo "---> " . $james->get_name();
?>
</body>
</html>

Pas 21:Suprascrierea metodelor

Uneori (cand se foloseste mostenirea) este nevoie sa se modifice modul
in care lucreaza o metoda in clasa de baza/parinte.
De exemplu sa spunem ca metoda set_nume() din clasa angajati
trebuie sa faca ceva diferit fata de ceea ce se intampla in clasa
persoana. =>
Se suprascrie, metoda set_nume din clasa persoana prin declararea
acesteia in clasa angajati, astfel:

<?php
class persoane{
// adaugarea de proprietati in mod explicit unei clase este optionala dar indicata
var $nume;
function __construct($persoane_nume) {
$this->nume = $persoane_nume;
}
public function get_nume() {
return $this->nume;
}
//protected methods and properties restrictioneaza accesul la aceste elemente.
protected function set_nume($new_nume) {
if (nume != "Jimmy Two Guns") {
$this->nume = strtoupper($new_nume);
} }}
// 'extends' este cuvantul cheia care permite mostenirea ( inheritance)
class angajati extends persoane {
protected function set_nume($new_nume) {
if ($new_nume == "Stefan Sucks") {
$this->nume = $new_nume;
}}
function __construct($angajati_nume) {
$this->set_nume($angajati_nume);
} } ?>
Obs: set_nume () este diferit n clasa "angajati" fata de clasa printe: "persoan".

Pas 22: Sprascrierea Metodelor: partea 2

Uneori, este necesar sa se acceseze metode din clasa de baza pentru a

suprascrie metode din clasa copil.
n ex se suprascrie metoda set_nume () din clasa "angajati". Aceasta se
face astfel:

persoana::set_nume($new_nume);
Codul de mai sus are menirea de a accesa metoda set_nume () din clasa printe "persoan.

<?php
class persoana {
var $name;
function __construct($persoane_nume) {
$this->nume = $persoane_nume;
}
public function get_nume() {
return $this->nume;
}
//protected methods and properties restrict access to those elements.
protected function set_nume($new_nume) {
if (nume != "Jimmy Two Guns") {
$this->nume = strtoupper($new_nume);
}}}
// 'extends' is the keyword that enables inheritance
class angajati extends persoana {
protected function set_nume($new_nume) {
if ($new_nume == "Stefan Sucks") {
$this->name = $new_nume;
}
else if($new_nume == "Johnny Fingers") {
persoana::set_nume($new_nume);
}}
function __construct($angajati_nume) {
$this->set_nume($angajati_nume);
} }?>

Pas 23:Suprascrierea metodelor partea 3

Folosind :: se permite sa se precizeze numele clasei in care PHP va cauta metoda.
Persoana::set_nume() spune lui PHP sa caute metoda set_nume() in clasa persoana. Exista o
scurtatura in cazul in care se doreste sa se faca referirea la clasa parinte din clasa curenta, astfel:
se foloseste cuvantul cheie parent.
<?php
class persoane{
// explicitly adding class properties are optional - but is good practice
var $nume;
function __construct($persoane_nume) {
$this->nume = $persoane_nume;
}
public function get_nume() {
return $this->nume;
}
//protected methods and properties restrict access to those elements.
protected function set_nume($new_nume) {
if (nume != "Jimmy Two Guns") {
$this->nume = strtoupper($new_nume);
} }}
// 'extends' is the keyword that enables inheritance
class angajati extends persoane {
protected function set_nume($new_nume) {
if ($new_nume == "Stefan Sucks") {
$this->nume = $new_nume;
}
else if($new_nume == "Johnny Fingers") {
parent::set_nume($new_nume);
}}
function __construct($angajati_nume) {
$this->set_nume($angajati_nume);
}}
?>

Trecerea de la programarea procedurala PHP la cea OOP este necesara deoarece,

multe extensii PHP ca Smarty si Pear se bazeaza pe OOP.
Deci pentru a intelege cu adevarat frameworks trebuie sa se inteleaga mai intai
programarea OOP.
Avantajele functionale/practice
1. in proiectele mici OOP este nejustificata deci OOP in proiectele complexe in care
sunt implicate mai mult de 1 persoana ca programator
2. OOP este cea mai moderna cale de dezvoltare a software pentru majoritatea
limbajelor de programare Java, Perl PHP, Ruby, C#.
3. Invatarea programarii OOP in PHP implica invatarea acestui stil de programare
pentru toate limbajele.
Un mod comun de a ncepe un proiect orientat pe obiect este de a ncepe prin elaborarea
de scheme simple ale obiectelor.
Desenarea diagramelor obiect se face astfel:
se utilizeaza o hrtie i creion
se deseneaza chenare pentru a reprezenta fiecare obiect
n aceste chenare, se scrie lista de metode i proprieti pt fiecare obiect.
se folosesc tastele sgei i liniile de demarcaie dintre chenare pentru a indica relaiile
(mam - copil) dintre obiecte.

Exemple:
O clasa este tiparul, ea descrie cum ar trebui sa fie obiectele, ce sa faca si ce sa contina acestea.
Deci o clasa ar putea arata asa:
elefant.php
class Elephpant {
public $colour;
public function dance() {
echo "elephpant dances!\n";
}

Un obiect, pe de alt parte, este o instaniere real a clasei - sau un lucru real, cu valori i
comportamente. In exemplul de mai jos, $ele este obiect:
include('elephpant.php');
$ele = new Elephpant();

Se poate inspecta $ele folosind comanda print_r cu scopul de a verifica dac acesta este, de
fapt, un obiect ale clasei Elephpant,astfel:
include('elephpant.php');
$ele = new Elephpant();
print_r($ele);

Iesirea acestui script este:

Elephpant Object( [colour] =>)
Aceasta iesire arata ca avem un obiect de tip Elephpant cu o sg proprietate goala colour. Pentru
a afla informatii detaliate despre proprietatile obiectelor si valorie acestora se poate folosi
var_dump, care ofera mai multe detalii despre tipurile de date ale fiecarei proprietati. Aceasta
este foarte folosita pentru a depista sirurile goale, null-uri si false.

Prezentarea modului de utilizare a obiectele proprietatile si metodele lor

Incepem prin a seta proprietatea culoare;
pentru aceasta vom folosi operatorul de obiect care este: -> astfel:
include('elephpant.php');
$ele = new Elephpant();
// setarea proprietatii colour
$ele->colour = "blue";
// folosirea propriatatii
echo Elefantul este " . $ele->colour;
Iesirea acestui script este: elefantule este blue.
Proprietatea va ramane setata pt obiect pana cand obiectul va fi distrus, sau proprietatea
suprascrisa sau se foloseste unset.
Obiectele sunt o modalitate foarte buna de a pastra lucruri care se folosesc impreuna. De
exemplu informatiile despre un elefant sunt adevarate pt toti elefantii.
In mod similar se pot apela metodele unui obiect. Ca in exemplu:
// apelarea metodei dance
$ele->dance();
Se poate observa ca in apelul unui obiect se precizeaza numele obiectului urmat de
operatorul -> si numele metodei definite in clasa. Numele metodei este insotit de
paranteze rotunde care pot contine 0 sau n parametrii in functie de cum a fost declarata in
clasa.
Rezultatul acestei actiuni este: elephpant dances!
Pt ca metoda are rolul de a afisa pe ecran mesajul: : elephpant dances!

Mostenirea
Este declarata deja clasa Elephpant si se doreste sa se declare o clasa
Penguin.
Ambele mostenesc
clasa Animal care este clasa parinte, si arata astfel:
class Animal{
public $type = "animal";
public function dance()
{
echo $this->type . " dances!\n"; }}
Clasa Animal are o propritate "type",
i o metod dance().
Se utilizeaz proprietatea de type n metoda dance()pentru a crea ieirea,
se foloseste $this pentru a se face referire la obiectul curent.
n PHP, $this este un cuvnt cheie special care se refer la obiectul curent din
interiorul propriei sale clase.
Acum se poate crea o clasa Penguin care mosteneste de la clasa generala
Animal, prin utilizarea cuvintului cheie extends pentru a desemna ca se extinde
clasa parinte x:

class Penguin extends Animal {

public $type = "penguin";}

Clasa Penguin mosteneste proprietatea $type definite in clasa

Animal
care este rescrisa cu setarile facute in aceasta clasa ignoarand setarea
din clasa parinte.
Fara sa se declare o metoda dance(), pinguinul poate dansa.
include('animal.php');
include('penguin.php');
$tux = new Penguin();
$tux->dance();

Exemplul de mai sus ne returneaza mesajul penguin dances- folosind

1. metoda dance() din clasa Animal = este disponibila

deaorece clasa Penguin
mosteneste clasa Animal
2. proprietatea type = setata explicit in clasa Penguin ca
fiind penguin.

Metodele inadecvate ale clasei pot fi redefinite sau anulate de metode

dintr-o clasa copil.
Deci, mostenirea consta in faptul ca se pot declara anumite clase ca
fiind derivate din alte clase de baza. In cele mai multe situatii clasa
derivata (numita si clasa copil) extinde, primeste functionalitatile clasei
de baza (numita si clasa parinte). In acest fel se reduce foarte mult
cantitatea de cod necesara.
Obs in PHP se accepta doar mostenirea simpla, fiecare copil poate
mosteni de la un singur parinte. Nu exista restrictii la numarul de copii
pe care pot mosteni de la un singur parinte.

Mostenire simpla

Mostenire simpla

C
Mostenire simpla-nu
este valabila in PHP

Modificatori de acces
Proprietatea type este setata in clasa, dar poate sa fie setata la alta valoare din
pagina principal astfel:
$tux->type=giraffe inainte de a intreba daca danseaza.
Cateodata acesta este comportamentul dorit cateodata nu este dorit acest
comportament. Modificatorii de acces au rolul de a permite sau nu modificarea
proprietatile in afara clasei. In exempele anterioare s-a folosit modificatorul de acces
public. Pentru a nu se putea modifica valoare proprietatii type din afara clasei at
aceasta proprietate va devein privat in clasa Penguin, astfel:
class Penguin extends Animal {

private $type = "penguin";}

Codul urmator este un exemplu de a seta din afara clasei o proprietate type private, rezultatul
obtinut este: include('animal.php');
include('private_penguin.php');
$tux = new Penguin();
// change the type
$tux->type = "linux penguin";
// make tux dance
$tux->dance();?>

Eroarea aparuta: Fatal error: Access level to Penguin::$type must be public (as in class Animal)
in C:\xampp\htdocs\oop\private_penguin.php on line 2
Aceasta eroare apare deoarece se doreste sa se setez din index_private_penguin.php care este
programul main, proprietatea privata $type declarata in clasa Penguin, ceea ce nu se poate.
Daca este privata o proprietate ea nu se schimba in main.

Modificatorii de acces pot fi aplicati atat metodelor cat si proprietatilor.

Optiunile sunt: publice, private si protejate.
In PHP4 acest lucru nu era posibil si totul era public.
Pentru a se mentine compatibilitatea cu versiunile anterioare metodele si proprietatile
care nu au specificat un modificator de access sunt implicit publice.
In practica se recomanda ca fiecare metoda si proprietate sa fie insotita explicit de
modificatorii de acces doriti.
Public: modificatorul de acces public inseamna ca proprietatile si metodele pot fi
accesate de oriunde, atat in domeniul de aplicare a obiectului cat si din codul exterior
care opereaza cu obiectului.
Private: metodele si proprietatile sunt accesibile numai din clasa in care au fost
definite.
Protected: metodele si proprietatile sunt accesibile atat din interiorul clasei care au fost
definite cat si din clasele care extind aceasta clasa sau implementeaza aceasta clasa.
Acesta este ideal pentru situatiile in care nu se doreste
ca un cod extern sa modifice clasa,
se doreste sa se poate extinde clasa si sa se foloseasca proprietatile si metodele in
clasele extinse.
=> Protected este mai flexibil ca privat si aproape intotdeauna cea mai buna
alegere.

Folosind modificatorii de acces =>

controla modul in care se pot accesa metodele si proprietatile unei
clase.
In exemplul anterior se demonstreaza ca proprietatile si metodele nu
pot fi accesate din afara domeniului de definitie a clasei daca sunt
private sau protected daca sunt publice ele pot fi accesate si
modificate de oriunde.
Poate fi foarte folositor sa se declare o metoda protected in cazul in
care acestea sunt metode interne folositoare pentru alte metode a
altor clase care nu se doresc a fi folosite in mod direct.
Deci avem clasa animal cu proprietatea type si metoda dance(). Se creaza
o clasa Penguin care este clasa extinsa sau fiu a clasei animal.

De exemplu se pp ca se defineste o clasa care

reprezinta un cont bancar. Clasa poate include
proprietatiile:
1. Numar cont
2. Posesor cont
3. Data infiintarii contului
4. Balanta curenta
5. Informatia aferenta posesorului contului

Definirea si instantierea unei clase

-exemplu definirea unei clase ContBancar.
Class ContBancar
{ var $balanta=0;
function creaza_depozit($suma)
{ $this->balanta =this->balanta+$suma;
}
function obtine_balanta()
{
return $this->balanta;
}}
Explicatie:
Clasa are o sg proprietate: $balanta-definita de o instructiune var
are 2 metode creaza_depozit() si obtine_balanta()
Numele clasei este specificat de catre instructiunea class.
Definitia clasei este defimitata prin 2 acolade.
Obs definirea proprietatilor se face cu ajutorul instructiunii var.
Initializarea proprietatii $balanta cu zero nu a fost necesara dar a fost facuta pt a simplifica
citirea programului
Metodele se definesc folosind cuvantul cheie function. Metodele au rolul de a excuta actiuni,
la fel ca functiile. Diferenta dintre functii si metode este legata de amplasarea lor, si anume
metodele sunt definite in interiorlul claselor iar functiile in exteriorul acestora.
$this are semnificatie similara cu pronumele posesiv pers I sg (meu). Cand o metode face
referire la forma $this->balanta se considera ca referinta face trimitere la proprietatea
$balanta a obiectului curent. PHP stabileste valoarea variabilei speciale $this la fiecare
invocare a unei metode

Instantierea unui obiect

Pt a determina modul de functionare a clasei ContBancar se initializeaza si se foloseste un obiect
ContBancar astfel:
$cont=new ContBancar();
$cont->creaza_depozit(100);
echo balanta este.$cont->obtine_balanta();

Instantierea unei clase se face prin operatorul "new", avand urmatoarea forma
generala:
$nume_variabila = new nume_clasa();
Variabila "$nume_variabila" contine o referinta la clasa "nume_clasa". In exemplul
anterior:
$cont=new ContBancar();
In continuare se apeleaza metodele clasei respective, asta se face prin operatorul de
referinta "->" ca mai jos:
$nume_variabila->Metoda1();
Variabila apeleaza metoda cu numele "Medoda1()", care apartine clasei "nume_clasa".
In
exemplul
anterior:
$cont->creaza_depozit(100);
si
$cont->obtine_balanta()
Stergerea instantelor unei clase se face simplu prin apelarea functiei:
unset($nume_variabila);
Dupa aceasta stergere, orice apel de genul "$nume_variabila->Metoda1();" va fi
semnalat ca eroare.
Obs: metoda obtine_balanta() obtine accesul la valoarea proprietatii obiectului, dar nu
modifica valoarea acestuia. O astfel de metoda se numeste metoda de obtinere sau
accesor. Metoda precum creaza_depozit() se numeste metoda de configurare.

Definirea unui constructor

Constructorul este o functie cu acelasi nume ca al clasei. PHP apeleaza automat
aceasta functie la invocarea lui new.
Redefinirea clasei ContBancar folosind constructori:
Class ContBancar2
{ var $cont_id;
var $nume_posesor;
var $balanta=0;
function ContBancar2($id,$nume,$suma)
{ $this->cont_id=$id;
$this->nume_posesor=$nume;
$this->balanta=$suma;}
function creaza_depozit($suma)
{$this->balanta=$this->balanta+$suma;
return $this->balanta;}
}
// folosirea clasei
$cont=new ContBancar2(1,Pop Raveca,1000);
echo Contul $cont->cont_id apartine lui $cont->nume_posesor ;
$cont->creaza_depozit(100);
echo <br/>Balanta este.$cont->balanta;?>
Obs: valorile constructorului se folosesc pt a stabili valorile initiale ale proprietatilor
noului obiect. Instructiunile 2 si 3 din folosirea clasei obtin acces la proprietatile
obiectului in mod direct nu prin meode de accesor.

PHP permite modificarea directa a valorilor proprietatilor astfel:

$cont->balanta=100;
echo <br> Balanta este .$cont->balanta;
Prima instructiune modifica valoarea proprietatii $balanta in mod direct nu prin invocarea
metodei creaza_depozit().
OBS:
Programele care au acces la proprietatile obiectelor si le modifica in mod direct
distrug incapsularea obiectelor si implicit elimina avantajele programarii orientate
obiect.

Utilizarea mostenirii
<?php
include contBancar2.php;
class ContCurent extends ContBancar2
{
var $cec_nr;
function ContCurent($id,$nume,$suma,$cecnr)
{
$this->cont_id=$id;
$this->nume_posesor=$nume;
$this->balanta=$suma;
$this->$cec_nr=$cecnr;
}
function incasare_cec($cecnr,$suma)
{
$this->balanta= $this->balanta -$suma;
}
function obtine_balanta()
{
return $this->balanta;
}}
In exemplu se foloseste instructiunea include pt a se optine acces la definitia clasei
parinte, dar clasa parinte si cea copil se pot defini si in acelasi fisier.
Cuvantul cheie extends stabileste identitatea clasei ContCurent drept clasa copil.
- se folosese in cadrul instructiunii class

Clasa copil defineste o proprietate $cec_nr care contine numarul filei initiale a
urmatorului carnet de cecuri care va fi emis
-defineste un constructor si 2 metode : incasare_cec() si obtine_balanta()
-mai include proprietatile si metodele definite in clasa parinte:
$cont_id,$nume_posesor si $balanta precum si metoda:creaza_depozit();
-constructorul atribuie valori proprietatiilor mostenite dar si proprietatiilor
definite in clasa copil.
Instructiuni care creaza un obiect ContCurent si care invoca metode asupra acestuia:
$cont= new ContCurent(12,Pop Vasalie,111,11111);
$cont->incasare_cec(121,250);
$cont->creaza_depozit(350);
echo Balanta curenta:.$cont->obtine_balanta();
Obs: metoda creaza_depozit este definita in clasa parinte dar se invoca ca si cand s-a
creat in clasa copil. Deci, metodele mostenite nu necesita un tratament de natura
speciala.

Redefinirea metodelor
In unele cazuri o clasa extinsa include o metoda care nu este adecvata pt o clasa care
in alte conditii poate fi derivata pt a obtine o clasa copil. In loc de a defini noua clasa fara
referire la clasa existenta se poate redefini metoda inadecvata.
<?php
class ContBancar3
{ var $cont_id;
var $nume_posesor;
Var $balanta=1;
function ContBancar3($id,$nume,$suma)
{ $this->cont_id=$id;
$this->nume_posesor=$nume;
$this->balanta=$suma; }
function inchide_cont()
{ $suma=$this->balanta;
$this->balanta=1;
return $suma;}}?>

Se deriveaza o clasa care reprezinta un nou tip de cont bancar purtator de

dobanda.
La inchiderea contului programul trebuie sa calculeze dobanda cumulata de la
ultima declaratie lunara
si sa returneze clientului atat dobanda cat si balanta curenta.
Deci vom redefini metoda inchide_cont();

In exemplu se invoca metoda definita de clasa copil nu cea creata in clasa parinte. In
acest context metoda definita de clasa parinte a fost anulata(redefinita) de catre
metoda definita de clasa copil.
<?php
class ContEconomii extends ContBancar3
{
function inchide_cont($zile,$rata)
{
$suma=$this->balanta*$rata*($zile/360);
$suma=$suma+$this->balanta;
$this->balanta=1;
return $suma;
}
}
$cont=new ContEconomii(103,"Filipoiu Zanfir",2000);
echo "Filipoiu Zanfir primeste ".$cont->inchide_cont(20,0.08);
?>

Metoda inchide_cont() se auto-apeleaza in mod repetat pana cand serverul Apache

anuleaza cererea

Invocarea corecta:
<?php

class ContEconomii extends ContBancar3

{
function inchide_cont($zile,$rata)
{
$suma=ContBancar3::inchide_cont();
$suma=$suma+$suma*$rata*($zile/360);
return $suma;
}
}
$cont=new ContEconomii(103,"Filipoiu Zanfir",2000);
echo "Filipoiu Zanfir primeste ".$cont->inchide_cont();
?>

Prin specificarea numelui clasei, urmat semnul :: se poate indica programului PHP sa
invoce metoda definita in clasa parinte, nu cea definita in clasa copil.

Tablouri de obiecte
-este un tablou ce face referire la obiecte.
-se creaza o clasa parinte si 2 copil. Clasele copil vor face referire la constructorul clasei
parinte, reutilizand in mod eficient caracteristica furnizata de clasa parinte.
-la instantierea claselor copil se stocheaza referintele intr-un tablou->tablou de obiecte.
Tabloul va fi parcurs si se va instanta functia afisare a clasei parinte pt a vizualiza datele
tabloului.

Exemplu de definire a unei clase ce calculeaza aria si perimetrul unui dreptunghi

Calcule_drept.php :
<?php
class Calcule
{
var $lungime;
var $latime;
function Calcule($lungime,$latime)
{
$this->lungime = $lungime;
$this->latime = $latime;
}
function area()
{
return $this->lungime*$this->latime;
}
function perimeter()
{
return ($this->lungime + $this->latime)*2;
}
}?>
$this este un dreptunghi(adica un obiect) cu metodele
perimetru si aria si proprietatiile $lungime si $latime

Constructori
-se apeleaza la crearea unui obiect;
-realizeaza in general operatii utile de initializare, de ex: stabilirea atributelor de pornire sau
crearea de alte obiecte necesare obiectului
-pana in php5 aveau acelasi nume cu numele clasei;
-in php5 are un nume special __construct()
-pt a se realiza compatibilizarea PHP va cauta o functie care sa detina acelasi nume cu numele
clasei in caz ca nu gaseste _construct()
-se poate apela manual;
-rolul sau principal este sa se apeleze automat cand se creaza un obiect.
Ex: de declarare a unei clase cu un costructor:
class expclasa
{
function __construct($parametru)
{
echo Constructorul apelat cu parametrul $parametru;
}
}
Obs:PHP 5 accepta supraincarcarea functiilor adica pot exista mai multe functii cu acelasi nume
dar cu numar diferit de tipuri sau parametrii se revine

Destructori
-este opusul unui constructor si a fost introdus in PHP5
-poate contine anumite functionalitati care sa se execute inainte de distrugerea clasei.
Distrugerea clasei se va face atunci cand toate referintele la ea au fost eliminate sau au iesit din
domeniul de valabilitate.
-trebuie sa detina numele __destruct().
-nu accepta parametrii
Instantierea clasei
-dupa ce s-a creat o clasa se creaza un obiect adica o anumita individualitate care este un
membru al acelei clase.
Procedeu ce poarta denumirea de instantiere a unei clase sau crearea unei instante .
-un obiect se creaza folosind cuvantul cheie new urmat de numele clasei care se va instanta de
obiect urmat sau nu de parametrii.
Exemplu de creare a unei clase

Clasele care se pot folosi in dezvoltarea WEB pot contine pagini, componente de
interfete utilizator, liste de cumparaturi, categorii de produse sau clienti, tratare de
erori.
Obiectele sunt instante ale acestor clase.
Un exemplu de utilizare a claselor si a avantajelor mostenirii:
Se creaza o clasa Pagina avand ca rol principal limitarea de cod HTML necesar crearii
unei pagini noi=> Pagina este creata de o clasa ceea ce ar trebui sa restranga
libertatea de creare a ei si permite adaugarea de functionalitati noi in timp scurt.
Avantaje:
1. Modificarea elementelor paginii unui site se face intr-un sg loc(se adauga un buton)
2. Identificarea paginii care este vizualizata;
3. Continut prestabilit dar care se poate modifica ca ex: titlul, metaetichetele
4. Inlocuirea elementelor standard (butoanele standard cu alte butoane)
Elemetele care au o probabilitate mare de modificare se declara ca atribute ale clasei:
de exemplu: continutul, titlul, cuvintele cheie si butoanele unei pagini.
Operatiile: afisarea si formatarea continutului in pagina.
Se creaza un fisier numit clasapagina.inc care se va introduce in toate fisierele php care
alcatuiesc site-ul.

Functia isURLCurrentPage($url) determina daca URL unui buton indica pagina curenta cu
ajutorul functie strpos() cu care se poate testa daca URL-ul dat este continut in una din
variabilele de configurare ale serverului. Daca sirul din $url se afla in variabila superglobala
$_SERVER*PHP_SELF+ instructiunea strpos($_SERVER*PHP_SELF+ ,$url) va returna un
numar in caz contrar va returna false.

Functia DisplayButon()-afiseaza butonul corespunzator paginii curent ca fiind inactiv si insotit

de un patrat rosu. Restul butoanelor sunt active si insotite de un patrat negru.

Instantierea clasei pentru crearea paginii home.php se face:

Instantierea clasei pentru crearea paginii contact.php se face:

Mostenirea de la clasa Pagina

Crearea unei clase ce deseneaza figuri geometrice.