PHP objektorienterad programmering (OOP) koncept med exempel

Vad är OOPs?

Objektorienterad programmering är en metod för mjukvaruutveckling som modellerar en applikation kring verkliga objekt som anställda, bilar och bankkonton. En klass definierar egenskaperna och metoderna för ett verkligt objekt. Ett objekt är en instans av en klass.

De tre grundläggande komponenterna i objektorientering är:

• Objektorienterad analys – systemets funktionalitet
• Objektorienterad design – systemets arkitektur
• Objektorienterad programmering – implementering av applikationen

Objektorienterade programmeringsprinciper

De tre huvudprinciperna för OOP är:

• inkapsling – detta handlar om att dölja implementeringsdetaljerna och endast exponera metoderna. De huvudsakliga syftena med inkapsling är att:
  • Minska komplexiteten i mjukvaruutvecklingen – genom att dölja implementeringsdetaljerna och bara avslöja operationerna blir det enkelt att använda en klass.
  • Skydda ett objekts interna tillstånd – åtkomst till klassvariablerna sker via metoder som get och set. Detta gör klassen flexibel och enkel att underhålla.
  • Tillåt att klassens interna implementering ändras utan att behöva oroa sig för att förstöra koden som använder klassen.
• Arv – detta handlar om förhållandet mellan klasser. Förhållandet tar formen av en förälder och ett barn. Barnet använder de metoder som definieras i förälderklassen. Huvudsyftet med arv är:
  • Återanvändbarhet – ett antal underordnade objekt kan ärva från samma förälder. Detta är mycket användbart när vi måste tillhandahålla gemensamma funktioner som att lägga till, uppdatera och ta bort data från databasen.
• polymorfism – detta handlar om att ha ett enda gränssnitt med många olika implementeringar. Huvudsyftet med polymorfism är:
  • För att förenkla underhållet av applikationer och göra dem mer utbyggbara.

Hoppsan Concepts i PHP

PHP är ett objektorienterat skriptspråk; det stöder alla ovanstående principer. Ovanstående principer uppnås via:

• inkapsling – via användning av metoderna ”get” och ”set” och åtkomstmodifierare.
• Arv – genom att använda nyckelordet extends
• polymorfism – via användandet av nyckelordet implements

Nu när vi har den grundläggande kunskapen om OOP och hur det stöds i PHP, låt oss titta på exempel som implementerar ovanstående principer.

Vad är UML?

Unified Modeling Language (UML) är en teknik som används för att designa och dokumentera objektorienterade system.

UML producerar ett antal dokument, men vi kommer att titta på klassdiagrammet, vilket är mycket viktigt för objektorienterad PHP-programmering.

Exempel på klassdiagram

Klassdiagram nyckel

• Ocuco-landskapet övre lådan innehåller klassnamnet
• Ocuco-landskapet mellanlåda innehåller klassvariablerna
• Ocuco-landskapet nedre ruta innehåller klassmetoderna
• Ocuco-landskapet minus (-) skylt betyder privat räckvidd
• Ocuco-landskapet mer (+) tecken betyder offentlig räckvidd
• Ocuco-landskapet hash (#) skylt betyder skyddad omfattning

Hur man skapar en klass i PHP

Klassnyckelordet används för att definiera en klass i PHP. Nedan finns reglerna för att skapa en klass i PHP.

• Klassnamnet ska börja med en bokstav
• Klassnamnet kan inte vara ett reserverat PHP-ord
• Klassnamnet får inte innehålla mellanslag

Låt oss säga att vi vill skapa en klass för att representera djur. Vi börjar med att identifiera de egenskaper som är gemensamma för alla djur.

• Alla djur tillhör en familj, till exempel växtätare, köttätare etc.
• Alla djur äter mat

Diagrammet nedan visar klassdiagrammet för djuret.

Låt oss nu koda vår Animal-klass.

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

HÄR,

• ”privat $family, $food” betyder att variablerna inte kan nås direkt utanför klassen (inkapsling).
• ”public function __construct($family…)” är PHP:s konstruktormetoden. Denna funktion anropas varje gång en instans av klassen skapas. I det här fallet sätter vi `family` och `food`.
• ”public function get…()” är metoden som används för att komma åt familje- eller livsmedelsvärdet (inkapsling)
• ”public function set…()” är den metod som används för att ställa in familjens eller livsmedelsvärdet (inkapsling)

Hur man implementerar arv i PHP

Vi ska jobba med en ko och ett lejon. Både kon och lejonet ärver från Djurklassen.

Klassdiagrammet nedan visar sambanden.

Observera att kon ärver från Animal-klassen och definierar även sin egen variabel och metoder.

Låt oss nu koda 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;
    }
}
?>

Låt oss nu koda Lion-klassen.

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

HÄR,

• ”class … extends Animal” gör att klasserna Cow och Lion använder metoder från klassen Animal (arv).

Hur man skapar ett objekt av klassen

Djur-, ko- och lejonklasserna bör alla vara i samma katalog för enkelhetens skull.

Låt oss nu skapa applikationen som använder våra klasser.

PHP-klassexempel

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

Testar vår applikation

Låt oss nu titta på vår applikation i en webbläsare.

Båda objekten återanvänder metoderna get_family och get_food som ärvts från Animal-klassen, vilket demonstrerar arv i praktiken.

Hur man implementerar polymorfism i PHP

Låt oss säga att vi vill utveckla en applikation som ansluter till olika databasmotorer som t.ex. MySQL och SQL Server men använder samma enhetliga gränssnitt. Vi kan skapa ett gränssnitt som definierar standardmetoderna och en abstract-klass som implementerar de vanliga metoderna.

• Gränssnitt – det liknar en klass. Den definierar bara metoderna och parametrarna.
• AbstracT-klass – det är en klass som inte kan användas för att skapa ett objekt direkt. Dess syfte är att tillhandahålla partiella eller hela implementeringar av vanliga metoder.

Klassdiagrammet nedan illustrerar förhållandet mellan våra magmusklertract-klass, gränssnitt och implementeringsklasser.

Låt oss nu bygga våra magmusklertract-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;
    }
}
?>

HÄR,

• "magmusklertrac"t-klass" betyder att klassen inte kan användas direkt för att skapa ett objekt
• "$host, $db..." är klassvariabler som är gemensamma för alla implementeringar
• ”function __construct(…)” är klasskonstruktormetoden som ställer in de gemensamma variabelvärdena vid initialisering

Låt oss nu skapa gränssnittet som innehåller standardmetoderna, vilka kommer att implementeras olika beroende på databasmotorn.

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

HÄR,

• "gränssnitt" är nyckelordet för att skapa gränssnitt
• "offentlig funktion...(...)" är standardmetoderna som bör implementeras

Låt oss nu skapa de konkreta klasserna som kommer att utöka DBCommonMethods-klassen och implementera DBInterface-gränssnittet. Först, MySQLDrivrutin.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 */ }
}
?>

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

HÄR,

• ”klassen … utökar DBCommonMethods” använder metoderna i DBCommonMethods
• ”… implements DBInterface” säkerställer att klassen tillhandahåller standardmetoderna oavsett vilken databasdrivrutin som används.

Koden som använder ovanstående klasser skulle se ut så här:

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

eller:

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

Resten av koden skulle vara densamma för båda drivrutinerna, till exempel:

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

Detta är polymorfism i praktiken: samma metod anropar arbete på vilken drivrutin som helst som implementerar gränssnittet, så den omgivande koden ändras aldrig när du byter databasmotor.

Vanliga frågor