Conceptul de programare orientată pe obiecte (POO) în PHP cu exemplu

Ce este OOP-urile?

Programarea orientată pe obiecte este o abordare a dezvoltării de software care modelează o aplicație în jurul obiectelor din lumea reală, cum ar fi angajați, mașini și conturi bancare. O clasă definește proprietățile și metodele unui obiect din lumea reală. Un obiect este o instanță a unei clase.

Cele trei componente de bază ale orientării obiectelor sunt:

• Analiza orientată pe obiect – funcționalitatea sistemului
• Proiectare orientată pe obiecte – arhitectura sistemului
• Programare orientată obiect – implementarea aplicației

Principii de programare orientată pe obiecte

Cele trei principii majore ale POO sunt:

• încapsularea – aceasta se referă la ascunderea detaliilor de implementare și expunerea doar a metodelor. Principalele scopuri ale încapsulării sunt:
  • Reduceți complexitatea dezvoltării software - prin ascunderea detaliilor de implementare și doar expunerea operațiunilor, utilizarea unei clase devine ușoară.
  • Protejați starea internă a unui obiect – accesul la variabilele clasei se face prin metode precum get și set. Acest lucru face ca clasa să fie flexibilă și ușor de întreținut.
  • Permiteți modificarea implementării interne a clasei fără a vă face griji cu privire la ruperea codului care utilizează clasa.
• Moştenire – aceasta se referă la relația dintre clase. Relația ia forma unui părinte și a unui copil. Copilul folosește metodele definite în clasa părinte. Scopul principal al moștenirii este:
  • Reutilizabilitate – mai mulți copii pot moșteni de la același părinte. Acest lucru este foarte util atunci când trebuie să oferim funcționalități comune, cum ar fi adăugarea, actualizarea și ștergerea datelor din baza de date.
• polimorfismul – aceasta se referă la existența unei singure interfețe cu multe implementări diferite. Scopul principal al polimorfismului este:
  • Pentru a simplifica întreținerea aplicațiilor și a le face mai extensibile.

OOP-uri Concepts în PHP

PHP este un limbaj de scripting orientat pe obiecte; acesta susține toate principiile de mai sus. Principiile de mai sus sunt realizate prin:

• încapsularea – prin utilizarea metodelor „get” și „set” și a modificatorilor de acces.
• Moştenire – prin utilizarea cuvântului cheie extends
• polimorfismul – prin utilizarea cuvântului cheie implements

Acum că avem cunoștințele de bază despre OOP și cum este suportat PHP, să analizăm exemple care implementează principiile de mai sus.

Ce este UML?

Limbajul unificat de modelare (UML) este o tehnică utilizată pentru proiectarea și documentarea sistemelor orientate pe obiecte.

UML produce o serie de documente, dar vom analiza diagrama de clase, care este foarte importantă pentru programarea PHP orientată pe obiecte.

Exemplu de diagramă de clasă

Cheia diagramei de clasă

• cutia superioară conține numele clasei
• caseta din mijloc conţine variabilele clasei
• caseta inferioara conţine metodele clasei
• minus (-) semnul înseamnă domeniu privat
• mai mult (+) semn înseamnă sferă publică
• hash (#) semn înseamnă domeniu protejat

Cum se creează o clasă în PHP

Cuvântul cheie class este folosit pentru a defini o clasă în PHP. Mai jos sunt regulile pentru crearea unei clase în PHP.

• Numele clasei ar trebui să înceapă cu o literă
• Numele clasei nu poate fi un cuvânt rezervat PHP
• Numele clasei nu poate conține spații

Să presupunem că vrem să creăm o clasă pentru reprezentarea animalelor. Vom începe prin identificarea caracteristicilor comune tuturor animalelor.

• Toate animalele aparțin unei familii, cum ar fi erbivoarele, carnivorele etc.
• Toate animalele mănâncă mâncare

Diagrama de mai jos prezintă diagrama de clase pentru animal.

Să codăm acum clasa noastră Animal.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

AICI,

• „private $family, $food” înseamnă că variabilele nu pot fi accesate direct în afara clasei (încapsulare).
• „public function __construct($family…)” este metoda constructorului PHP. Această funcție este apelată de fiecare dată când este creată o instanță a clasei. În acest caz, setăm familia și alimentul.
• „public function get…()” este metoda utilizată pentru a accesa valoarea familiei sau a alimentelor (încapsulare)
• „public function set…()” este metoda utilizată pentru a seta valoarea familiei sau a alimentului (încapsulare)

Cum se implementează moștenirea în PHP

Vom lucra cu o vacă și un leu. Atât vaca, cât și leul moștenesc din clasa Animal.

Diagrama de clasă de mai jos arată relațiile.

Rețineți că vaca moștenește de la clasa Animal și își definește propria variabilă și metode.

Să codăm acum clasa Cow.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Să codăm acum clasa Lion.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

AICI,

• „class … extends Animal” face ca clasele Cow și Lion să utilizeze metode din clasa Animal (moștenire).

Cum se creează un obiect al clasei

Clasele Animal, Cow și Lion ar trebui să fie toate în același director din motive de simplitate.

Să creăm acum aplicația care folosește clasele noastre.

Exemplu de clasă PHP

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Testarea aplicației noastre

Să vizualizăm acum aplicația noastră într-un browser web.

Ambele obiecte reutilizează metodele get_family și get_food moștenite de la clasa Animal, ceea ce demonstrează moștenirea în acțiune.

Cum se implementează polimorfismul în PHP

Să presupunem că vrem să dezvoltăm o aplicație care se conectează la diferite motoare de baze de date, cum ar fi MySQL și SQL Server, dar folosește aceeași interfață uniformă. Putem crea o interfață care definește metodele standard și un abstracClasa t care implementează metodele comune.

• interfaţă – este asemănător cu o clasă. Acesta definește doar metodele și parametrii.
• Abstracclasa t – este o clasă care nu poate fi folosită pentru a crea direct un obiect. Scopul său este de a oferi implementări parțiale sau întregi ale metodelor comune.

Diagrama de clase de mai jos ilustrează relația dintre abdomenul nostrutracclasa t, interfața și clasele de implementare.

Haideți acum să ne creăm abdomenultracclasa t.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

AICI,

• „abdomen”trac„clasa t” înseamnă că clasa nu poate fi utilizată direct pentru a crea un obiect
• „$host, $db…” sunt variabile de clasă comune tuturor implementărilor
• „function __construct(…)” este metoda constructorului de clasă care setează valorile variabilelor comune la inițializare

Să creăm acum interfața care conține metodele standard, care vor fi implementate diferit în funcție de motorul bazei de date.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

AICI,

• „interfață” este cuvântul cheie pentru crearea interfețelor
• „funcția publică…(…)” sunt metodele standard care ar trebui implementate

Să creăm acum clasele concrete care vor extinde clasa DBCommonMethods și vor implementa interfața DBInterface. Mai întâi, MySQLDriver.php:

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Apoi, MSSQLServerDriver.php:

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

AICI,

• „clasa … extends DBCommonMethods” folosește metodele din DBCommonMethods
• „… implementează DBInterface” asigură că clasa oferă metodele standard indiferent de driverul bazei de date utilizat.

Codul care folosește clasele de mai sus ar arăta astfel:

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

Sau:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

Restul codului ar fi același pentru ambele drivere, cum ar fi:

<?php
$db->db_connect();
$db->insert($data);
?>

Acesta este polimorfismul în acțiune: aceeași metodă apelează la lucru pe orice driver care implementează interfața, astfel încât codul din jur nu se schimbă niciodată atunci când schimbați motoarele de baze de date.

Întrebări frecvente