Het concept van objectgeoriënteerd programmeren (OOP) in PHP met een voorbeeld.

Wat zijn OOP's?

Objectgeoriënteerd programmeren is een benadering van softwareontwikkeling waarbij een applicatie wordt gemodelleerd naar objecten uit de echte wereld, zoals werknemers, auto's en bankrekeningen. Een klasse definieert de eigenschappen en methoden van een object uit de echte wereld. Een object is een instantie van een klasse.

De drie basiscomponenten van objectoriëntatie zijn:

• Objectgeoriënteerde analyse – functionaliteit van het systeem
• Objectgeoriënteerd ontwerp – architectuur van het systeem
• Objectgeoriënteerd programmeren – implementatie van de applicatie

Objectgeoriënteerde programmeerprincipes

De drie belangrijkste principes van OOP zijn:

• Inkapseling – Dit betreft het verbergen van de implementatiedetails en het alleen tonen van de methoden. De belangrijkste doelen van encapsulatie zijn:
  • Verminder de complexiteit van softwareontwikkeling: door de implementatiedetails te verbergen en alleen de bewerkingen bloot te leggen, wordt het gebruik van een klasse eenvoudig.
  • Bescherm de interne status van een object – toegang tot de klassevariabelen verloopt via methoden zoals `get` en `set`. Dit maakt de klasse flexibel en gemakkelijk te onderhouden.
  • Sta toe dat de interne implementatie van de klasse kan worden gewijzigd zonder dat dit gevolgen heeft voor de code die de klasse gebruikt.
• Erfenis – Dit betreft de relatie tussen klassen. De relatie neemt de vorm aan van een ouder en een kind. Het kind gebruikt de methoden die in de ouderklasse zijn gedefinieerd. Het belangrijkste doel van overerving is:
  • Herbruikbaarheid – meerdere subklassen kunnen van dezelfde ouderklasse erven. Dit is erg handig wanneer we gemeenschappelijke functionaliteit moeten bieden, zoals het toevoegen, bijwerken en verwijderen van gegevens uit de database.
• polymorfisme – Dit betreft het hebben van één interface met veel verschillende implementaties. Het belangrijkste doel van polymorfisme is:
  • Om het onderhoud van applicaties te vereenvoudigen en ze beter uitbreidbaar te maken.

OOP's Concepts in PHP

PHP is een objectgeoriënteerde scripttaal; het ondersteunt alle bovengenoemde principes. Deze principes worden bereikt door:

• Inkapseling – door gebruik te maken van de methoden "get" en "set", en toegangsmodifiers.
• Erfenis – door gebruik te maken van het trefwoord extends
• polymorfisme – door gebruik te maken van het trefwoord 'implements'

Nu we de basiskennis hebben van OOP en hoe het wordt ondersteund PHPLaten we eens kijken naar voorbeelden die de bovenstaande principes in de praktijk brengen.

Wat is UML?

Unified Modeling Language (UML) is een techniek die wordt gebruikt voor het ontwerpen en documenteren van objectgeoriënteerde systemen.

UML produceert een aantal documenten, maar we zullen kijken naar het klassendiagram, dat erg belangrijk is voor objectgeoriënteerd PHP-programmeren.

Voorbeeld van klassediagram

Klassediagramsleutel

• De bovenste doos bevat de klassenaam
• De middelste doos bevat de klassevariabelen
• De onderste doos bevat de klassenmethoden
• De min (-) teken betekent privébereik
• De meer (+) teken betekent publieke reikwijdte
• De hekje (#) teken betekent beschermde reikwijdte

Hoe maak je een klasse in PHP

Het class trefwoord wordt gebruikt om een ​​klasse in PHP te definiëren. Hieronder staan ​​de regels voor het maken van een klasse in PHP.

• De klassenaam moet beginnen met een letter
• De klassenaam mag geen gereserveerd PHP-woord zijn
• De klassenaam mag geen spaties bevatten

Stel, we willen een klasse creëren om dieren te representeren. We beginnen met het identificeren van de kenmerken die alle dieren gemeen hebben.

• Alle dieren behoren tot een familie, zoals herbivoren, carnivoren, enzovoort.
• Alle dieren eten voedsel

Onderstaande afbeelding toont het klassendiagram voor het dier.

Laten we nu onze Animal-klasse programmeren.

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

HIER,

• “private $family, $food” betekent dat de variabelen niet rechtstreeks buiten de klasse toegankelijk zijn (encapsulatie).
• “public function __construct($family…)” is de PHP-constructormethode. Deze functie wordt aangeroepen wanneer een instantie van de klasse wordt aangemaakt. In dit geval stellen we de familie en het eten in.
• “public function get…()” is de methode die gebruikt wordt om toegang te krijgen tot de familie- of voedingswaarde (encapsulatie).
• “public function set…()” is de methode die gebruikt wordt om de familie- of voedingswaarde (encapsulatie) in te stellen.

Hoe implementeer je overerving in PHP?

We gaan werken met een koe en een leeuw. Zowel de koe als de leeuw erven van de klasse Dieren.

In onderstaand klassendiagram zijn de relaties weergegeven.

Merk op dat de koe overerft van de klasse Animal en ook haar eigen variabelen en methoden definieert.

Laten we nu de Cow-klasse programmeren.

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

Laten we nu de Lion-klasse programmeren.

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

HIER,

• “class … extends Animal” zorgt ervoor dat de klassen Cow en Lion methoden van de klasse Animal kunnen gebruiken (overerving).

Hoe maak je een object van de klasse aan?

Voor de eenvoud moeten de klassen Animal, Cow en Lion zich allemaal in dezelfde map bevinden.

Laten we nu de applicatie maken die gebruikmaakt van onze klassen.

PHP-klasse voorbeeld

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

Onze applicatie testen

Laten we onze applicatie nu eens bekijken in een webbrowser.

Beide objecten hergebruiken de get_family- en get_food-methoden die zijn overgeërfd van de Animal-klasse, wat overerving in de praktijk illustreert.

Hoe implementeer je polymorfisme in PHP?

Stel, we willen een applicatie ontwikkelen die verbinding maakt met verschillende database-engines, zoals... MySQL en SQL De server gebruikt echter dezelfde uniforme interface. We kunnen een interface maken die de standaardmethoden en een absolute waarde definieert.tract klasse die de gemeenschappelijke methoden implementeert.

• Interface – het is vergelijkbaar met een klasse. Het definieert alleen de methoden en parameters.
• Abstract-klasse – het is een klasse die niet kan worden gebruikt om rechtstreeks een object te maken. Het doel is om gedeeltelijke of volledige implementaties van veelgebruikte methoden te bieden.

Het onderstaande klassendiagram illustreert de relatie tussen onze abstract klasse-, interface- en implementatieklassen.

Laten we nu onze buikspieren trainen.tract-klasse.

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

HIER,

• “buikspierentrac"t class" betekent dat de klasse niet rechtstreeks gebruikt kan worden om een ​​object te creëren.
• “$host, $db…” zijn klassevariabelen die in alle implementaties voorkomen.
• “function __construct(…)” is de constructormethode van de klasse die de waarden van de gemeenschappelijke variabelen instelt bij de initialisatie.

Laten we nu de interface maken die de standaardmethoden bevat. Deze methoden zullen, afhankelijk van de database-engine, op verschillende manieren worden geïmplementeerd.

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

HIER,

• “interface” is het sleutelwoord voor het maken van interfaces
• “publieke functie…(…)” zijn de standaardmethoden die moeten worden geïmplementeerd

Laten we nu de concrete klassen maken die de klasse DBCommonMethods zullen uitbreiden en de interface DBInterface zullen implementeren. Eerst, 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 */ }
}
?>

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

HIER,

• “klasse … breidt DBCommonMethods uit” gebruikt de methoden in DBCommonMethods
• “… implementeert DBInterface” zorgt ervoor dat de klasse de standaardmethoden biedt, ongeacht de gebruikte database-driver.

De code die gebruikmaakt van de bovenstaande klassen zou er als volgt uitzien:

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

Of:

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

De rest van de code zou voor beide stuurprogramma's hetzelfde zijn, bijvoorbeeld:

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

Dit is polymorfisme in actie: dezelfde methodeaanroepen werken op elke driver die de interface implementeert, waardoor de omringende code nooit verandert wanneer je van database-engine wisselt.

Veelgestelde vragen