Conceptul de programare orientată pe obiecte (POO) PHP Tutorial cu exemplu
Fiona Brown
Ce este OOP-urile?
Orientat pe obiect este o abordare a dezvoltării software care modelează aplicația în jurul obiectelor din lumea reală, cum ar fi angajați, mașini, conturi bancare etc. O clasă definește proprietățile și metodele unui obiect din lumea reală. Un obiect este o apariție a unei clase.
Cele trei componente de bază ale orientării obiectelor sunt;
- Analiza orientată pe obiect – funcționalitatea sistemului
- Proiectare orientată obiect – arhitectura sistemului
- Programare orientată obiect – implementarea aplicației
Principii de programare orientată pe obiecte
Cele trei principii majore ale POO sunt;
- încapsularea – aceasta se preocupă de ascunderea detaliilor implementării și doar de expunerea metodelor. Scopul principal al încapsulării este de a;
- 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, ceea ce face ca clasa să fie flexibilă și ușor de întreținut.
- Implementarea internă a clasei poate fi schimbată fără să vă faceți griji cu privire la spargerea codului care folosește clasa.
- Moştenire – aceasta este preocupată de 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 – un număr de 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 este preocupată de a avea o singură formă, dar mai multe moduri de implementare diferite. Scopul principal al polimorfismului este;
- Simplificați întreținerea aplicațiilor și făcându-le mai extensibile.
OOP-uri Concepts în PHP
PHP este un limbaj de scripting orientat obiect; susține toate principiile de mai sus. Principiile de mai sus sunt realizate prin;
- încapsularea – prin utilizarea metodelor „get” și „set” etc.
- Moştenire – prin utilizarea cuvântului cheie extins
- polimorfismul – prin utilizarea cuvântului cheie implements
Acum că avem cunoștințele de bază despre OOP și cum este suportat PHP, să ne uităm la exemple care implementează principiile de mai sus
Ce este UML?
Unified Modeling Language UML este o tehnică utilizată pentru proiectarea și documentarea sistemelor orientate pe obiecte.
UML produce o serie de documente, dar ne vom uita la diagrama de clasă, 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 (-) semn înseamnă domeniul 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 cu identificarea trăsăturilor care sunt comune tuturor animalelor.
- Toate animalele aparțin unei familii, cum ar fi un ierbivor, carnaval etc.
- Toate animalele mănâncă mâncare
Diagrama de mai jos arată diagrama pentru animal
Acum să codificăm clasa noastră de animale
<?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).
- „Funcția publică __construct($family…)” este metoda constructorului php. Această funcție este apelată ori de câte ori a fost creată o instanță a clasei. În acest caz, stabilim familia și mâncarea.
- „public function get…()” este metoda folosită pentru a accesa familia sau valoarea alimentară (încapsulare)
- „Setul de funcții publice…()” este metoda utilizată pentru a seta valoarea familiei sau a alimentelor (încapsulare)
Cum implementați 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 din clasa de animale și își definește și propria variabilă și metode.
Să codifică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ă codificăm acum clasa Lion
<?php
class Lion extends Animal
{
public function __construct($family, $food)
{
parent::__construct($family, $food);
}
}
?>
AICI,
- „clasa… extinde Animal” face ca vaca și leul să folosească metode din clasa Animal (Moștenire).
Cum se creează obiectul 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('Canirval', '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ă vedem acum aplicația noastră într-un browser web
Fantastic drept! Să ne uităm acum la al treilea principiu al OOP, polimorfismul.
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 o clasă abstractă care implementează metodele comune.
- interfaţă – este asemănător cu o clasă. Acesta definește doar metodele și parametrii.
- Clasa abstractă – 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 clasă de mai jos ilustrează relația dintre clasa noastră abstractă, interfața și clasele de implementare.
Acum să creăm clasa noastră abstractă
<?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,
- „clasa abstractă” înseamnă că clasa nu poate fi utilizată direct pentru a crea obiectul php
- „$host,$db…” sunt variabile de clasă comune tuturor implementărilor
- „funcția __construct(…)” este metoda constructorului de clasă PHP 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 extinde interfața DBInterface. 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 }
} ?>
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 … extinde DBCommonMethods” utilizează metodele din DBCommonMethods
- „… implementează DBInterface” asigură că clasa furnizează metode standard, indiferent de driverul de bază de date utilizat.
Utilizarea codului de mai sus Codul care utilizează clasa de mai sus ar arăta astfel
<?php $db = new MySQLDriver($host,$db,$uid,$password); ?>
Or
<?php $db = new MSSQLServerDriver ($host,$db,$uid,$password); ?>
Restul codului ar fi același pentru ambii șoferi, cum ar fi;
<?php $db->db_connect(); $db->insert($data); ?>
Rezumat
- Programarea orientată pe obiecte OOP este o tehnică puternică care modelează aplicațiile după obiecte din lumea reală
- O clasă este o reprezentare a obiectelor din lumea reală cu proprietăți și metode
- Cele trei principii de bază ale POO sunt:
- încapsularea
- Moştenire
- polimorfismul
