PHP objektorientert programmeringskonsept (OOP) med eksempel

Hva er OOPs?

Objektorientert programmering er en tilnærming til programvareutvikling som modellerer en applikasjon rundt virkelige objekter som ansatte, biler og bankkontoer. En klasse definerer egenskapene og metodene til et virkelig objekt. Et objekt er en forekomst av en klasse.

De tre grunnleggende komponentene i objektorientering er:

• Objektorientert analyse – funksjonalitet til systemet
• Objektorientert design – systemets arkitektur
• Objektorientert programmering – implementering av applikasjonen

Objektorienterte programmeringsprinsipper

De tre hovedprinsippene for OOP er:

• innkapsling – dette handler om å skjule implementeringsdetaljene og kun eksponere metodene. Hovedformålene med innkapsling er å:
  • Reduser programvareutviklingskompleksiteten – ved å skjule implementeringsdetaljene og bare avsløre operasjonene, blir det enkelt å bruke en klasse.
  • Beskytt den interne tilstanden til et objekt – tilgang til klassevariablene skjer via metoder som get og set. Dette gjør klassen fleksibel og enkel å vedlikeholde.
  • Tillat at den interne implementeringen av klassen endres uten å bekymre deg for å bryte koden som bruker klassen.
• Arv – dette handler om forholdet mellom klasser. Forholdet har form av en forelder og et barn. Barnet bruker metodene som er definert i foreldreklassen. Hovedformålet med arv er:
  • Gjenbrukbarhet – flere barn kan arve fra samme forelder. Dette er veldig nyttig når vi må tilby felles funksjonalitet, som å legge til, oppdatere og slette data fra databasen.
• polymorfisme – dette handler om å ha et enkelt grensesnitt med mange forskjellige implementeringer. Hovedformålet med polymorfisme er:
  • For å forenkle vedlikehold av applikasjoner og gjøre dem mer utvidbare.

OOP Concepts i PHP

PHP er et objektorientert skriptspråk; det støtter alle prinsippene ovenfor. Prinsippene ovenfor oppnås via:

• innkapsling – via bruk av «get»- og «set»-metodene, og tilgangsmodifikatorer.
• Arv – ved bruk av nøkkelordet extends
• polymorfisme – ved bruk av nøkkelordet implements

Nå som vi har grunnleggende kunnskap om OOP og hvordan det støttes i PHP, la oss se på eksempler som implementerer prinsippene ovenfor.

Hva er UML?

Unified Modeling Language (UML) er en teknikk som brukes til å designe og dokumentere objektorienterte systemer.

UML produserer en rekke dokumenter, men vi skal se på klassediagrammet, som er svært viktig for objektorientert PHP-programmering.

Eksempel på klassediagram

Klassediagramnøkkel

• Ocuco øvre boks inneholder klassenavnet
• Ocuco midtboks inneholder klassevariablene
• Ocuco nedre boks inneholder klassemetodene
• Ocuco minus (-) skilt betyr privat rekkevidde
• Ocuco pluss (+) skilt betyr offentlig omfang
• Ocuco hash (#) skilt betyr beskyttet omfang

Hvordan lage en klasse i PHP

Klasse nøkkelordet brukes til å definere en klasse i PHP. Nedenfor er reglene for å lage en klasse i PHP.

• Klassenavnet skal begynne med en bokstav
• Klassenavnet kan ikke være et reservert PHP-ord
• Klassenavnet kan ikke inneholde mellomrom

La oss si at vi ønsker å lage en klasse for å representere dyr. Vi begynner med å identifisere trekkene som er felles for alle dyr.

• Alle dyr tilhører en familie, som planteetere, kjøttetere osv.
• Alle dyr spiser mat

Diagrammet nedenfor viser klassediagrammet for dyret.

La oss nå kode Animal-klassen vår.

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

HER,

• «privat $family, $food» betyr at variablene ikke kan nås direkte utenfor klassen (innkapsling).
• «public function __construct($family…)» er PHP-konstruktørmetoden. Denne funksjonen kalles hver gang en instans av klassen opprettes. I dette tilfellet setter vi family og food.
• «public function get…()» er metoden som brukes for å få tilgang til familie- eller matverdien (innkapsling)
• «public function set…()» er metoden som brukes til å angi familie- eller matverdien (innkapsling)

Slik implementerer du arv i PHP

Vi skal jobbe med en ku og en løve. Både kua og løven arver fra Dyreklassen.

Klassediagrammet nedenfor viser sammenhengene.

Merk at kua arver fra Animal-klassen og definerer sin egen variabel og metoder også.

La oss nå kode Cow-klassen.

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

La oss nå kode Lion-klassen.

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

HER,

• «klasse … utvider Animal» gjør at Cow- og Lion-klassene bruker metoder fra Animal-klassen (arv).

Hvordan opprette et objekt av klassen

Klassene Animal, Cow og Lion bør alle være i samme katalog for enkelhets skyld.

La oss nå lage applikasjonen som bruker klassene våre.

Eksempel på PHP-klasse

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

Testing av søknaden vår

La oss nå se applikasjonen vår i en nettleser.

Begge objektene gjenbruker metodene get_family og get_food som er arvet fra Animal-klassen, noe som demonstrerer arv i praksis.

Slik implementerer du polymorfisme i PHP

La oss si at vi ønsker å utvikle en applikasjon som kobler seg til forskjellige databasemotorer, som f.eks. MySQL og SQL Server, men bruker det samme ensartede grensesnittet. Vi kan lage et grensesnitt som definerer standardmetodene og en abstract-klassen som implementerer de vanlige metodene.

• Interface – det ligner på en klasse. Den definerer bare metodene og parameterne.
• AbstracT-klasse – det er en klasse som ikke kan brukes til å lage et objekt direkte. Formålet er å gi delvis eller hele implementeringer av vanlige metoder.

Klassediagrammet nedenfor illustrerer forholdet mellom magemusklene våretract-klasse, grensesnitt og implementeringsklasser.

La oss nå bygge magemusklene våretract-klassen.

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

HER,

• magemusklertract-klassen» betyr at klassen ikke kan brukes direkte til å opprette et objekt
• "$host, $db..." er klassevariabler som er felles for alle implementeringer
• «function __construct(…)» er klassekonstruktørmetoden som setter de vanlige variabelverdiene ved initialisering

La oss nå lage grensesnittet som inneholder standardmetodene, som vil bli implementert forskjellig avhengig av databasemotoren.

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

HER,

• "grensesnitt" er nøkkelordet for å lage grensesnitt
• "offentlig funksjon...(...)" er standardmetodene som bør implementeres

La oss nå lage de konkrete klassene som vil utvide DBCommonMethods-klassen og implementere DBInterface-grensesnittet. Først, 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 */ }
}
?>

Så, 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 */ }
}
?>

HER,

• «klasse … utvider DBCommonMethods» bruker metodene i DBCommonMethods
• «… implements DBInterface» sikrer at klassen tilbyr standardmetodene uavhengig av hvilken databasedriver som brukes.

Koden som bruker klassene ovenfor vil se slik ut:

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

Eller:

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

Resten av koden ville være den samme for begge driverne, for eksempel:

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

Dette er polymorfisme i aksjon: den samme metoden kaller arbeid på enhver driver som implementerer grensesnittet, slik at den omkringliggende koden aldri endres når du bytter databasemotorer.

Spørsmål og svar