PHP-objektiorientoidun ohjelmoinnin (OOP) käsite esimerkin kanssa

Mikä on OOPs?

Olio-ohjelmointi on ohjelmistokehityksen lähestymistapa, joka mallintaa sovellusta reaalimaailman objektien, kuten työntekijöiden, autojen ja pankkitilien, ympärille. Luokka määrittelee reaalimaailman objektin ominaisuudet ja metodit. Objekti on luokan instanssi.

Objektiorientaation kolme peruskomponenttia ovat:

• Olio-analyysi – järjestelmän toimivuus
• Oliopohjainen suunnittelu – järjestelmän arkkitehtuuri
• Olioohjelmointi – sovelluksen toteutus

Olio-ohjelmoinnin periaatteet

OOP:n kolme pääperiaatetta ovat:

• kapselointi – tämä koskee toteutuksen yksityiskohtien piilottamista ja vain metodien paljastamista. Kapseloinnin päätarkoitukset ovat:
  • Vähennä ohjelmistokehityksen monimutkaisuutta – piilottamalla toteutustiedot ja paljastamalla vain toiminnot, luokan käyttäminen on helppoa.
  • Suojaa objektin sisäinen tila – luokkamuuttujiin pääsee käsiksi metodien, kuten get ja set, kautta. Tämä tekee luokasta joustavan ja helposti ylläpidettävän.
  • Salli luokan sisäisen toteutuksen muuttaminen ilman huolta luokkaa käyttävän koodin rikkomisesta.
• Perintö – tämä liittyy luokkien väliseen suhteeseen. Suhde on vanhemman ja lapsen muotoinen. Lapsi käyttää vanhemman luokassa määriteltyjä metodeja. Periytymisen päätarkoitus on:
  • Uudelleenkäytettävyys – useat lapset voivat periä samalta vanhemmalta. Tämä on erittäin hyödyllistä, kun meidän on tarjottava yhteisiä toimintoja, kuten tietojen lisääminen, päivittäminen ja poistaminen tietokannasta.
• polymorfismi – tämä koskee yhden rajapinnan käyttöä useilla eri toteutuksilla. Polymorfismin päätarkoitus on:
  • Yksinkertaistaa sovellusten ylläpitoa ja tehdä niistä laajennettavia.

Oho Concepts PHP:ssä

PHP on oliopohjainen skriptikieli; se tukee kaikkia edellä mainittuja periaatteita. Yllä mainitut periaatteet saavutetaan seuraavien avulla:

• kapselointi – käyttämällä “get”- ja “set”-metodeja sekä käyttöoikeusmääreitä.
• Perintö – käyttämällä avainsanaa extends
• polymorfismi – käyttämällä avainsanaa implements

Nyt meillä on perustiedot OOP:sta ja sen tuesta PHP, katsotaanpa esimerkkejä, jotka toteuttavat yllä olevia periaatteita.

Mikä on UML?

Unified Modeling Language (UML) on tekniikka, jota käytetään oliopohjaisten järjestelmien suunnitteluun ja dokumentointiin.

UML tuottaa useita dokumentteja, mutta tarkastelemme luokkakaaviota, joka on erittäin tärkeä olio-ohjelmoinnissa.

Esimerkki luokkakaaviosta

Luokkakaavion avain

• ylempi laatikko sisältää luokan nimen
• keskimmäinen laatikko sisältää luokan muuttujat
• alempi laatikko sisältää luokan metodit
• miinus (-) merkki tarkoittaa yksityistä soveltamisalaa
• lisää (+) merkki tarkoittaa julkista ulottuvuutta
• hash (#) merkki tarkoittaa suojattua ulottuvuutta

Kuinka luoda luokka PHP: llä

Luokka-avainsanaa käytetään luokan määrittämiseen PHP:ssä. Alla on säännöt luokan luomiseksi PHP:ssä.

• Luokan nimen tulee alkaa kirjaimella
• Luokan nimi ei voi olla PHP:n varattu sana
• Luokan nimi ei saa sisältää välilyöntejä

Oletetaan, että haluamme luoda luokan eläinten esittämistä varten. Aloitamme tunnistamalla kaikille eläimille yhteiset ominaisuudet.

• Kaikki eläimet kuuluvat johonkin heimoon, kuten kasvinsyöjät, lihansyöjät jne.
• Kaikki eläimet syövät ruokaa

Alla oleva kaavio näyttää eläimen luokkakaavion.

Koodataan nyt Animal-luokkamme.

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

TÄSSÄ,

• ”private $family, $food” tarkoittaa, että muuttujiin ei voida päästä suoraan luokan ulkopuolelta (kapselointi).
• ”public function __construct($family…)” on PHP:n konstruktorimetodi. Tätä funktiota kutsutaan aina, kun luokan instanssi luodaan. Tässä tapauksessa asetamme familyn ja foodin.
• ”public function get…()” on menetelmä, jota käytetään perheen tai ruoan arvon (kapseloinnin) käyttämiseen.
• ”public function set…()” on menetelmä, jota käytetään perheen tai ruoan arvon asettamiseen (kapselointi)

Kuinka toteuttaa periytyminen PHP:ssä

Työskentelemme lehmän ja leijonan kanssa. Sekä lehmä että leijona perivät Animal-luokasta.

Alla oleva luokkakaavio näyttää suhteet.

Huomaa, että lehmä perii Animal-luokasta ja määrittelee myös omat muuttujansa ja metodinsa.

Koodataan nyt Cow-luokka.

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

Koodataan nyt Lion-luokka.

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

TÄSSÄ,

• ”luokka … laajentaa Eläin-luokkaa” saa Cow- ja Lion-luokat käyttämään Eläin-luokan metodeja (periytyminen).

Kuinka luoda luokan objekti

Animal-, Cow- ja Lion-luokkien tulisi olla kaikki samassa hakemistossa yksinkertaisuuden vuoksi.

Luodaan nyt sovellus, joka käyttää luokkiamme.

PHP-luokan esimerkki

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

Testaamme sovellustamme

Katsotaanpa nyt sovellustamme verkkoselaimessa.

Molemmat objektit käyttävät uudelleen Animal-luokalta perimiään get_family- ja get_food-metodeja, mikä havainnollistaa periytymistä käytännössä.

Kuinka toteuttaa polymorfismi PHP:ssä

Oletetaan, että haluamme kehittää sovelluksen, joka muodostaa yhteyden eri tietokantamoottoreihin, kuten MySQL ja SQL Palvelin, mutta käyttää samaa yhtenäistä rajapintaa. Voimme luoda rajapinnan, joka määrittelee standardimetodit ja abs-taulukon.tract-luokka, joka toteuttaa yleiset metodit.

• liitäntä – Se on samanlainen kuin luokka. Se määrittelee vain menetelmät ja parametrit.
• Abstract-luokka – Se on luokka, jota ei voida käyttää objektin luomiseen suoraan. Sen tarkoituksena on tarjota osittaisia ​​tai kokonaisia ​​toteutuksia yleisistä menetelmistä.

Alla oleva luokkakaavio havainnollistaa vatsalihaksiemme välistä suhdettatract-luokka, rajapinta ja toteutusluokat.

Luodaanpa nyt vatsalihaksettract-luokka.

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

TÄSSÄ,

• "vatsalihaksettract-luokka” tarkoittaa, että luokkaa ei voida käyttää suoraan objektin luomiseen
• ”$host, $db…” ovat luokkamuuttujia, jotka ovat yhteisiä kaikille toteutuksille
• ”function __construct(…)” on luokan rakentajametodi, joka asettaa yhteisten muuttujien arvot alustuksen yhteydessä.

Luodaan nyt rajapinta, joka sisältää standardimetodit, jotka toteutetaan eri tavoin tietokantamoottorista riippuen.

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

TÄSSÄ,

• "rajapinta" on avainsana rajapintojen luomiseen
• ”julkinen tehtävä…(…)” ovat vakiomenetelmiä, jotka tulisi ottaa käyttöön

Luodaan nyt konkreettiset luokat, jotka laajentavat DBCommonMethods-luokkaa ja toteuttavat DBInterface-rajapinnan. Ensin, MySQLOhjain.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 */ }
}
?>

Sitten 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 */ }
}
?>

TÄSSÄ,

• ”luokka … laajentaa DBCommonMethods-luokkaa” käyttää DBCommonMethods-luokassa olevia metodeja
• ”… toteuttaa DBInterfacen” varmistaa, että luokka tarjoaa vakiometodit käytetystä tietokanta-ajurista riippumatta.

Yllä olevia luokkia käyttävä koodi näyttäisi tältä:

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

Tai:

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

Loput koodista olisi sama molemmille ajureille, kuten:

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

Tämä on polymorfismia toiminnassa: sama metodi kutsuu työtä mille tahansa ajurille, joka toteuttaa rajapinnan, joten ympäröivä koodi ei koskaan muutu, kun vaihdat tietokantamoottoria.

UKK