PHP objektorienteeritud programmeerimise (OOP) kontseptsioon koos näitega

Mis on OOPs?

Objektorienteeritud programmeerimine on tarkvaraarenduse lähenemisviis, mis modelleerib rakendust reaalse maailma objektide, näiteks töötajate, autode ja pangakontode, ümber. Klass määratleb reaalse maailma objekti omadused ja meetodid. Objekt on klassi eksemplar.

Objektorientatsiooni kolm põhikomponenti on:

• Objektorienteeritud analüüs – süsteemi funktsionaalsus
• Objektorienteeritud disain – süsteemi arhitektuur
• Objektorienteeritud programmeerimine – rakenduse juurutamine

Objektorienteeritud programmeerimise põhimõtted

OOP-i kolm peamist põhimõtet on:

• Kapseldamine – see puudutab rakenduse üksikasjade varjamist ja ainult meetodite paljastamist. Kapseldamise peamised eesmärgid on:
  • Vähendage tarkvaraarenduse keerukust – juurutamise üksikasju peites ja ainult toiminguid paljastades muutub klassi kasutamine lihtsaks.
  • Kaitse objekti sisemist olekut – klassimuutujatele pääseb ligi selliste meetodite kaudu nagu get ja set. See muudab klassi paindlikuks ja hõlpsasti hooldatavaks.
  • Luba klassi sisemise implementatsiooni muutmine ilma, et peaks muretsema klassi kasutava koodi rikkumise pärast.
• Pärisosa – see tegeleb klasside vahelise suhtega. Suhe toimub vanema ja lapse kujul. Laps kasutab vanema klassis määratletud meetodeid. Pärimise peamine eesmärk on:
  • Korduvkasutatavus – samalt vanemalt saab pärida mitu tütart. See on väga kasulik, kui peame pakkuma ühiseid funktsioone, näiteks andmete lisamist, värskendamist ja kustutamist andmebaasist.
• Polümorfism – see puudutab ühe liidese olemasolu paljude erinevate implementatsioonidega. Polümorfismi peamine eesmärk on:
  • Rakenduste haldamise lihtsustamiseks ja laiendatavamaks muutmiseks.

OOP-d Concepts PHP-s

PHP on objektorienteeritud skriptimiskeel; see toetab kõiki ülaltoodud põhimõtteid. Ülaltoodud põhimõtted saavutatakse järgmiselt:

• Kapseldamine – meetodite „get” ja „set” ning juurdepääsumodifikaatorite abil.
• Pärisosa – märksõna „extends” abil
• Polümorfism – märksõna „implements” abil

Nüüd on meil põhiteadmised OOP-ist ja selle toetamisest PHP, vaatame näiteid, mis rakendavad ülaltoodud põhimõtteid.

Mis on UML?

Ühendatud modelleerimiskeel (UML) on tehnika, mida kasutatakse objektorienteeritud süsteemide kavandamiseks ja dokumenteerimiseks.

UML loob hulga dokumente, kuid me vaatleme klassiskeemi, mis on objektorienteeritud PHP programmeerimisel väga oluline.

Klassiskeemi näide

Klassiskeemi võti

• . ülemine kast sisaldab klassi nime
• . keskmine kast sisaldab klassi muutujaid
• . alumine kast sisaldab klassi meetodeid
• . miinus (-) märk tähendab privaatset ulatust
• . pluss (+) märk tähendab avalikku ulatust
• . räsi (#) märk tähendab kaitstud ulatust

Kuidas PHP-s klassi luua

Klassi märksõna kasutatakse PHP-s klassi määratlemiseks. Allpool on toodud PHP-s klassi loomise reeglid.

• Klassi nimi peaks algama tähega
• Klassi nimi ei saa olla PHP reserveeritud sõna
• Klassi nimi ei tohi sisaldada tühikuid

Oletame, et tahame luua klassi loomade esitamiseks. Alustame tunnuste tuvastamisest, mis on kõigile loomadele ühised.

• Kõik loomad kuuluvad mingisse sugukonda, näiteks taimtoidulised, lihasööjad jne.
• Kõik loomad söövad toitu

Allolev diagramm näitab looma klassiskeemi.

Nüüd kodeerime oma Animal klassi.

<?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;
    }
}
?>

SIIN,

• „privaatne $perekond, $toit” tähendab, et muutujatele ei saa klassiväliselt otse ligi pääseda (kapseldamine).
• „public function __construct($family…)” on PHP konstruktori meetod. Seda funktsiooni kutsutakse välja iga kord, kui klassi eksemplar luuakse. Antud juhul määrame perekonna ja toidu.
• „Public function get…()” on meetod, mida kasutatakse perekonna või toidu väärtusele juurdepääsuks (kapseldamine).
• „Public function set…()” on meetod, mida kasutatakse perekonna või toidu väärtuse määramiseks (kapseldamine)

Kuidas rakendada pärimist PHP-s

Töötame lehma ja lõviga. Nii lehm kui ka lõvi pärivad loomade klassist.

Allolev klassiskeem näitab seoseid.

Pane tähele, et lehm pärib klassilt Animal ning defineerib ka oma muutuja ja meetodid.

Kodeerime nüüd Cow klassi.

<?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;
    }
}
?>

Nüüd kodeerime Lõvi klassi.

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

SIIN,

• „Klass … laiendab klassi Loom“ paneb Cow ja Lion klassid kasutama Animal klassi meetodeid (pärimine).

Kuidas luua klassi objekt

Loomade, lehmade ja lõvi klassid peaksid lihtsuse huvides olema kõik samas kataloogis.

Loome nüüd rakenduse, mis kasutab meie klasse.

PHP klassi näide

<?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();
?>

Meie rakenduse testimine

Vaatame nüüd oma rakendust veebibrauseris.

Mõlemad objektid taaskasutavad Animal klassilt päritud get_family ja get_food meetodeid, mis demonstreerib pärimist tegevuses.

Kuidas polümorfismi PHP-s rakendada

Oletame, et tahame luua rakenduse, mis loob ühenduse erinevate andmebaasimootoritega, näiteks MySQL ja SQL Server, aga kasutab sama ühtset liidest. Saame luua liidese, mis määratleb standardmeetodid ja absoluutsetract-klass, mis rakendab tavalisi meetodeid.

• Interface – see sarnaneb klassiga. See määrab ainult meetodid ja parameetrid.
• Abstract-klass – see on klass, mida ei saa kasutada objekti otse loomiseks. Selle eesmärk on pakkuda levinud meetodite osalist või täielikku rakendamist.

Allolev klassidiagramm illustreerib meie kõhulihaste vahelist seosttract-klass, liides ja rakendusklassid.

Loome nüüd kõhulihasedtract-klass.

<?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;
    }
}
?>

SIIN,

• "kõhulihased"trac„t-klass” tähendab, et klassi ei saa objekti loomiseks otse kasutada
• „$host, $db…” on klassimuutujad, mis on ühised kõikidele implementatsioonidele.
• „function __construct(…)” on klassi konstruktori meetod, mis määrab initsialiseerimisel ühiste muutujate väärtused.

Loome nüüd liidese, mis sisaldab standardmeetodeid, mida rakendatakse andmebaasimootorist olenevalt erinevalt.

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

SIIN,

• "liides" on liideste loomise märksõna
• „avalik funktsioon…(…)” on standardmeetodid, mida tuleks rakendada

Loome nüüd konkreetsed klassid, mis laiendavad DBCommonMethods klassi ja implementeerivad DBInterface'i liidese. Esiteks, MySQLDraiver.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 */ }
}
?>

Seejärel 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 */ }
}
?>

SIIN,

• „Klass … laiendab DBCommonMethodsi” kasutab DBCommonMethodsi meetodeid
• „… rakendab DBInterface'i” tagab, et klass pakub standardmeetodeid olenemata kasutatavast andmebaasidraiverist.

Ülaltoodud klasse kasutav kood näeks välja selline:

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

Või:

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

Ülejäänud kood oleks mõlema draiveri puhul sama, näiteks:

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

See on polümorfism tegevuses: sama meetod kutsub tööle iga draiveri puhul, mis liidest rakendab, seega ümbritsev kood ei muutu kunagi andmebaasimootorite vahetamisel.

KKK