PHP objektorienterad programmering (OOPs) koncept Handledning med exempel

By: Fiona Brown Fiona Brown
Hours Uppdaterad

Vad är OOPs?

Objektorienterad är ett tillvägagångssätt för mjukvaruutveckling som modellerar tillämpningar kring verkliga objekt som anställda, bilar, bankkonton, etc. En klass definierar egenskaperna och metoderna för ett verkligt objekt. Ett objekt är en förekomst 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 – det handlar om att dölja implementeringsdetaljerna och bara avslöja metoderna. Huvudsyftet 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 lätt att underhålla.
  • Den interna implementeringen av klassen kan ändras utan att behöva oroa dig för att bryta koden som använder klassen.
  • Arv – det handlar om förhållandet mellan klasser. Relationen tar formen av en förälder och ett barn. Barnet använder de metoder som definierats i den överordnade klassen. Huvudsyftet med arv är;
  • Återanvändbarhet – ett antal barn, kan ärva från samma förälder. Detta är mycket användbart när vi måste tillhandahålla vanliga funktioner som att lägga till, uppdatera och ta bort data från databasen.
  • polymorfism – Det handlar om att ha en enda form men många olika implementeringssätt. Huvudsyftet med polymorfism är;
  • Förenkla underhållet av applikationer och gör dem mer utbyggbara.

Hoppsan Concepts i PHP

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

  • inkapsling – genom att använda ”get” och ”set” metoder etc.
  • Arv – genom att använda sökordet extends
  • polymorfism – genom att använda 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 som är mycket viktigt för objektorienterad php-programmering.

Exempel på klassdiagram

Hoppsan Concepts i PHP

Klassdiagram nyckel

  • Ocuco-landskapet Övre låda innehåller klassnamnet
  • Ocuco-landskapet mellanlåda innehåller klassvariablerna
  • Ocuco-landskapet nedre ruta innehåller klassmetoderna
  • Ocuco-landskapet minus (-) tecken betyder privat omfattning
  • 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 som växtätare, karneval etc.
  • Alla djur äter mat

Diagrammet nedan visar diagrammet för djuret

Skapa en klass i PHP

Låt oss nu koda vår djurklass

<?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 $familj, $mat" betyder att variablerna inte kan nås direkt utanför klassen (Encapsulation).
  • "public function __construct($family...)" är php-konstruktormetoden. Denna funktion anropas när en instans av klassen har skapats. I det här fallet sätter vi familjen och maten.
  • "public function get...()" är metoden som används för att komma åt familjen eller matvärdet (Encapsulation)
  • "public function set...()" är metoden som används för att ställa in familjen eller matens värde (Encapsulation)

RELATERADE ARTIKLAR

Hur 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.

implementera arv i PHP

Notera att kon ärver från djurklassen och definierar också 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,

  • "klass ... förlänger djur" gör att kon och lejon använder metoder från djurklassen (arv).

Hur man skapar objekt för 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('Canirval', '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

Arv i PHP

Fantastiskt rätt! Låt oss nu titta på den tredje principen för OOP, polymorfism.

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 abstrakt klass som implementerar de vanliga metoderna.

  • Gränssnitt – det liknar en klass. Den definierar bara metoderna och parametrarna.
  • Abstrakt 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 abstrakta klasser, gränssnitt och implementeringsklasser.

Arv i PHP

Låt oss nu skapa vår abstrakta 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,

  • "abstrakt klass" betyder att klassen inte kan användas direkt för att skapa ett php-objekt
  • "$host,$db..." är klassvariabler som är gemensamma för alla implementeringar
  • "function __construct(...)" är php-klasskonstruktormetoden som ställer in de vanliga variablernas värden vid initiering

Låt oss nu skapa gränssnittet som innehåller standardmetoderna som 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 utökar klassen DBCommonMethods och utökar DBInterface-gränssnittet. 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 } 
} ?>

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,

  • "klass ... utökar DBCommonMethods" använder metoderna i DBCommonMethods
  • "... implementerar DBInterface" säkerställer att klassen tillhandahåller standardmetoder oavsett vilken databasdrivrutin som används.

Användning av ovanstående kod Koden som använder ovanstående klass skulle se ut så här

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

Or

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

Resten av koden skulle vara densamma för båda drivrutinerna som;

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

Sammanfattning

  • Objektorienterad programmering OOP är en kraftfull teknik som modellerar applikationer efter verkliga objekt
  • En klass är en representation av verkliga objekt med egenskaper och metoder
  • De tre grundläggande principerna för OOP är;
  • inkapsling
  • Arv
  • polymorfism

Sammanfatta detta inlägg med: