Programarea orientată pe obiecte în PHP

Obiecte și clase

La crearea unui program în PHP și a blocurilor sale separate, este posibil să fie suficientă funcționalitatea oferită de funcții. Cu toate acestea, PHP are și alte posibilități de creare a programelor, reprezentate de programarea orientată pe obiecte (OOP).

În multe cazuri, programele care utilizează OOP sunt mai ușor de înțeles, de întreținut și de modificat.

Conceptele cheie ale paradigmei OOP sunt „clasa” și „obiectul”. Descrierea unui obiect este clasa, iar obiectul reprezintă o instanță a acestei clase. Putem face următoarea analogie: de exemplu, fiecare persoană are un nume, o anumită vârstă, greutate și alte caracteristici.

Adică, un anumit șablon care conține un set de caracteristici ale unei persoane - acest șablon poate fi numit clasă. O persoană reală cu un nume, vârstă și greutate specifică este un obiect sau o instanță a acestei clase.

Pentru a crea o clasă în PHP se folosește cuvântul cheie class, urmat de numele clasei și acoladele {} - blocul de cod al clasei. De exemplu, o nouă clasă care reprezintă un utilizator:

class Person
{}

Pentru a crea un obiect al clasei Person, se folosește cuvântul cheie new:

<?php
class Person
{ }

$person = new Person();
print_r($person);
?>

În acest caz, variabila $person este un obiect al clasei Person. Cu ajutorul funcției print_r() se poate afișa conținutul obiectului, la fel ca și în cazul array-urilor.

Nu contează dacă clasa este definită înainte sau după crearea obiectului. De exemplu, putem defini mai întâi variabila clasei și apoi clasa:

<?php
$person = new Person();

class Person
{ }
?>

Proprietăți și metode

O clasă poate conține variabile care descriu anumite caracteristici ale obiectului, starea acestuia și care sunt numite proprietăți sau atribute. De asemenea, clasa poate conține funcții, numite metode, care definesc comportamentul acesteia.

Astfel, vom adăuga în clasa Person câteva proprietăți și metode:

<?php
class Person
{
   public $name, $age;
     
   function hello()
   {
       echo "Hello!<br>";
   }
}
$tom = new Person();
$tom->name = "Tom"; // setarea proprietății $name
$tom->age = 36; // setarea proprietății $age
$personName = $tom->name;    // obținerea valorii proprietății $name
echo "Numele utilizatorului: " . $personName . "<br>";
$tom->hello(); // apelarea metodei hello()
print_r($tom);
?>

Aici, clasa Person conține două proprietăți: $name și $age. Proprietățile sunt declarate ca variabile obișnuite, precedate de un modificator de acces - în acest caz, modificatorul public.

Metodele sunt funcții obișnuite care execută anumite acțiuni. Aici, funcția hello() doar afișează un mesaj de salut.

După crearea unui obiect al clasei Person:

$tom = new Person();

Putem accesa proprietățile și metodele acestuia prin numele variabilei clasei. Pentru a accesa proprietățile și metodele obiectului se folosește operatorul de acces ->. De exemplu, pentru a seta valorile proprietăților:

$tom->name = "Tom"; // setarea proprietății $name
$tom->age = 36; // setarea proprietății $age

Sau pentru a obține valoarea (de exemplu, pentru a o atribui unei variabile):

$personName = $tom->name;    // obținerea valorii proprietății $name

Sau pentru a apela metodele obiectului:

$tom->hello(); // apelarea metodei hello()

Rezultatul în browser va fi:

Numele utilizatorului: Tom
Hello!
Person Object ( [name] => Tom [age] => 36 )

Putem, de asemenea, să setăm valori inițiale pentru proprietăți în clasă:

<?php
class Person
{
   public $name = "Undefined", $age = 18;
     
   function hello()
   {
       echo "Hello!<br>";
   }
}
$tom = new Person();
$tom->age = 36; // setarea proprietății $age

echo "Numele utilizatorului: " . $tom->name . "<br>";
echo "Vârsta utilizatorului: " . $tom->age . "<br>";
?>

Rezultatul în browser:

Numele utilizatorului: Undefined
Vârsta utilizatorului: 36

Cuvântul cheie this

Pentru a accesa proprietățile și metodele obiectului din interiorul clasei sale, se folosește cuvântul cheie this. De exemplu, definim o metodă în clasă pentru afișarea informațiilor despre obiect:

<?php
class Person
{
   public $name = "Undefined", $age = 18;
   
   function displayInfo()
   {
       echo "Name: " . $this->name ."; Age: " . $this->age . "<br>";
       // de asemenea se poate scrie
       // echo "Name: $this->name; Age: $this->age<br>";
   }
}
$tom = new Person();
$tom -> name = "Tom";
$tom -> displayInfo();   // Name: Tom; Age: 18
?>

Pentru a accesa câmpurile și metodele din interiorul clasei se folosește, de asemenea, operatorul de acces ->, precedat de $this. Acest $this indică obiectul curent. Ce înseamnă acest lucru în practică? De exemplu:

<?php
class Person
{
   public $name = "Undefined", $age = 18;
   
   function displayInfo()
   {
       echo "Name: $this->name; Age: $this->age<br>";
   }
}
$tom = new Person();
$tom -> name = "Tom";
$tom -> displayInfo();

$bob = new Person();
$bob -> name = "Bob";
$bob -> age = 25;
$bob -> displayInfo();
?>

La apelul:

$tom -> displayInfo();

$this va indica de fapt către variabila $tom. În timp ce la apelul:

$bob -> displayInfo();

$this va indica către variabila $bob.

Rezultatul în browser:

Name: Tom; Age: 18
Name: Bob; Age: 25

Compararea obiectelor

La compararea obiectelor claselor trebuie luate în considerare câteva aspecte. În special, la utilizarea operatorului de egalitate ==, două obiecte sunt considerate egale dacă reprezintă aceeași clasă și proprietățile lor au aceleași valori.

La utilizarea operatorului de echivalență ===, ambele obiecte sunt considerate egale dacă ambele variabile de clasă indică către aceeași instanță a clasei.

Să vedem un exemplu:

<?php
class Person
{
   public $name, $age;
   function displayInfo()
   {
       echo "Name: $this->name; Age: $this->age<br>";
   }
}
$tom = new Person();
$tom -> name = "Tom";
$tom -> age = 36;

$tomas = new Person();
$tomas -> name = "Tom";
$tomas -> age = 36;

if($tom == $tomas) echo "variabilele tom și tomas sunt egale<br>";
else echo "variabilele tom și tomas NU sunt egale<br>";

if($tom === $tomas) echo "variabilele tom și tomas sunt echivalente";
else echo "variabilele tom și tomas NU sunt echivalente";
?>

Aici, sunt comparate două variabile - $tom și $tomas. Ele reprezintă aceeași clasă Person, și proprietățile lor au aceleași valori. Cu toate acestea, ele reprezintă obiecte diferite. Prin urmare, la compararea cu operatorul ==, acesta va returna true, iar operatorul === - false:

variabilele tom și tomas sunt egale
variabilele tom și tomas NU sunt echivalente

Să luăm un alt exemplu, în care ambele variabile reprezintă același obiect:

<?php
$person = new Person();

$tom = $person;
$tom -> name = "Tom";
$tom -> age = 36;

$tomas = $person;

if($tom == $tomas) echo "variabilele tom și tomas sunt egale<br>";
else echo "variabilele tom și tomas NU sunt egale<br>";

if($tom === $tomas) echo "variabilele tom și tomas sunt echivalente";
else echo "variabilele tom și tomas NU sunt echivalente";
?>

Aici, obiectul clasei Person este creat doar o singură dată: $person = new Person();. Și apoi ambele variabile $tom și $tomas vor indica către acest obiect.

Nu contează pentru ce variabilă setăm proprietățile, deoarece în realitate va fi același obiect. În final, atât operatorul ==, cât și operatorul === vor returna true la comparare:

variabilele tom și tomas sunt egale
variabilele tom și tomas sunt echivalente