PHP objektorienteret programmering (OOP) koncept med eksempel

Hvad er OOPs?

Objektorienteret programmering er en tilgang til softwareudvikling, der modellerer en applikation omkring virkelige objekter såsom medarbejdere, biler og bankkonti. En klasse definerer egenskaberne og metoderne for et virkeligt objekt. Et objekt er en instans af en klasse.

De tre grundlæggende komponenter i objektorientering er:

• Objektorienteret analyse – systemets funktionalitet
• Objektorienteret design – systemets arkitektur
• Objektorienteret programmering – implementering af applikationen

Objektorienterede programmeringsprincipper

De tre hovedprincipper i OOP er:

• Indkapsling – dette handler om at skjule implementeringsdetaljerne og kun eksponere metoderne. Hovedformålene med indkapsling er at:
  • Reducer softwareudviklingens kompleksitet – ved at skjule implementeringsdetaljerne og kun afsløre operationerne bliver det nemt at bruge en klasse.
  • Beskyt et objekts interne tilstand – adgang til klassens variabler sker via metoder som get og set. Dette gør klassen fleksibel og nem at vedligeholde.
  • Tillad ændringer i klassens interne implementering uden at bekymre dig om at ødelægge den kode, der bruger klassen.
• Arv – dette handler om forholdet mellem klasser. Forholdet har form af en forælder og et barn. Barnet bruger de metoder, der er defineret i forælderklassen. Hovedformålet med arv er:
  • Genbrugelighed – en række børn kan arve fra den samme forælder. Dette er meget nyttigt, når vi skal tilbyde fælles funktioner såsom at tilføje, opdatere og slette data fra databasen.
• polymorfi – dette handler om at have en enkelt grænseflade med mange forskellige implementeringer. Hovedformålet med polymorfi er:
  • For at forenkle vedligeholdelsen af ​​applikationer og gøre dem mere udvidelige.

OOP'er Concepts i PHP

PHP er et objektorienteret scriptsprog; det understøtter alle ovenstående principper. Ovenstående principper opnås via:

• Indkapsling – via brugen af ​​"get"- og "set"-metoder og adgangsmodifikatorer.
• Arv – via brugen af ​​​​nøgleordet extends
• polymorfi – via brugen af ​​nøgleordet implements

Nu hvor vi har den grundlæggende viden om OOP og hvordan det understøttes i PHP, lad os se på eksempler, der implementerer ovenstående principper.

Hvad er UML?

Unified Modeling Language (UML) er en teknik, der bruges til at designe og dokumentere objektorienterede systemer.

UML producerer en række dokumenter, men vi vil se på klassediagrammet, som er meget vigtigt for objektorienteret PHP-programmering.

Eksempel på klassediagram

Klassediagramnøgle

• øvre boks indeholder klassenavnet
• mellemkasse indeholder klassevariablerne
• nederste boks indeholder klassemetoderne
• minus (-) skilt betyder privat rækkevidde
• mere (+) tegn betyder offentligt omfang
• hash (#) skilt betyder beskyttet omfang

Sådan opretter du en klasse i PHP

Klasse nøgleordet bruges til at definere en klasse i PHP. Nedenfor er reglerne for oprettelse af en klasse i PHP.

• Klassens navn skal starte med et bogstav
• Klassenavnet kan ikke være et PHP-reserveret ord
• Klassenavnet må ikke indeholde mellemrum

Lad os sige, at vi vil oprette en klasse til at repræsentationere dyr. Vi starter med at identificere de træk, der er fælles for alle dyr.

• Alle dyr tilhører en familie, såsom planteædere, rovdyr osv.
• Alle dyr spiser mad

Diagrammet nedenfor viser klassediagrammet for dyret.

Lad os nu kode vores Animal-klasse.

<?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" betyder, at variablerne ikke kan tilgås direkte uden for klassen (indkapsling).
• "public function __construct($family…)" er PHP-konstruktørmetoden. Denne funktion kaldes, hver gang en instans af klassen oprettes. I dette tilfælde sætter vi `family` og `food`.
• "public function get…()" er den metode, der bruges til at tilgå familie- eller fødevareværdien (indkapsling)
• "public function set…()" er den metode, der bruges til at indstille familie- eller fødevareværdien (indkapsling)

Sådan implementerer du arv i PHP

Vi vil arbejde med en ko og en løve. Både koen og løven arver fra Dyreklassen.

Klassediagrammet nedenfor viser sammenhængene.

Bemærk at koen arver fra Animal-klassen og også definerer sin egen variabel og metoder.

Lad os nu 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;
    }
}
?>

Lad os nu kode Lion-klassen.

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

HER,

• “klasse … udvider Animal” får Cow- og Lion-klasserne til at bruge metoder fra Animal-klassen (arv).

Sådan opretter du et objekt af klassen

Dyr-, ko- og løveklasserne bør alle være i den samme mappe for enkelhedens skyld.

Lad os nu oprette den applikation, der bruger vores klasser.

PHP klasse eksempel

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

Tester vores applikation

Lad os nu se vores applikation i en webbrowser.

Begge objekter genbruger metoderne get_family og get_food, der er arvet fra Animal-klassen, hvilket demonstrerer arv i aktion.

Sådan implementerer du polymorfi i PHP

Lad os sige, at vi ønsker at udvikle en applikation, der kan oprette forbindelse til forskellige databasemotorer, f.eks. MySQL og SQL Server, men bruger den samme ensartede grænseflade. Vi kan oprette en grænseflade, der definerer standardmetoderne og en abstract-klasse, der implementerer de almindelige metoder.

• grænseflade – det ligner en klasse. Den definerer kun metoderne og parametrene.
• AbstracT-klasse – det er en klasse, der ikke kan bruges til at oprette et objekt direkte. Dens formål er at levere delvise eller hele implementeringer af almindelige metoder.

Klassediagrammet nedenfor illustrerer forholdet mellem vores mavemusklertract-klasse, grænseflade- og implementeringsklasser.

Lad os nu lave vores mavemusklertract-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,

• "mavemusklertrac"t-klasse" betyder, at klassen ikke kan bruges direkte til at oprette et objekt
• "$host, $db..." er klassevariabler, der er fælles for alle implementeringer.
• "function __construct(…)" er den klassekonstruktørmetode, der sætter de fælles variabelværdier ved initialisering

Lad os nu oprette grænsefladen, der indeholder standardmetoderne, som vil blive implementeret forskelligt afhængigt af 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,

• "interface" er nøgleordet for at skabe grænseflader
• "offentlig funktion...(...)" er de standardmetoder, der bør implementeres

Lad os nu oprette de konkrete klasser, der vil udvide DBCommonMethods-klassen og implementere DBInterface-grænsefladen. 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 ... udvider DBCommonMethods" bruger metoderne i DBCommonMethods
• “… implements DBInterface” sikrer, at klassen leverer standardmetoderne uanset den anvendte databasedriver.

Koden, der bruger ovenstående klasser, ville se sådan ud:

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

Eller:

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

Resten af ​​koden ville være den samme for begge drivere, såsom:

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

Dette er polymorfi i aktion: den samme metode kalder arbejde på enhver driver, der implementerer grænsefladen, så den omgivende kode ændres aldrig, når du skifter databasemotorer.

Ofte Stillede Spørgsmål