PHP-lessen - les 13 - Basisprincipes van OOP (objectgeoriënteerd programmeren)

In de vorige lessen hebben we al gekeken naar de volgende gegevenstypen in PHP: booleans, gehele getallen, drijvende-kommagetallen, tekststrings en arrays. In deze les bespreken we nog een ander gegevenstype dat beschikbaar is in PHP: het object.
Objecten lijken in zekere zin op arrays — ze kunnen ook verschillende soorten gegevens bevatten, zoals getallen, tekst, arrays en zelfs andere objecten.

Wanneer objecten gegevens bevatten, noemen we deze gegevens de eigenschappen (of velden) van het object. Objecten kunnen ook functies bevatten, en deze functies noemen we methoden.

Maar objecten hebben twee belangrijke verschillen met arrays:

1. Objecten kunnen methoden bevatten.

Methoden zijn functies die worden aangeroepen namens een object. Door functies aan een object te koppelen, kunnen we vastleggen welke bewerkingen een object kan uitvoeren en welke acties op objecten kunnen worden uitgevoerd.

2. Objecten worden gemaakt op basis van klassen.

Voordat we een object kunnen maken, moeten we eerst een klasse definiëren. In een klasse beschrijven we welke velden en methoden een object zal hebben. Dit helpt om de structuur van objecten te begrijpen en maakt het eenvoudiger om te weten welke gegevens een object bevat en welke handelingen het uitvoert. Wanneer we een object van een klasse maken, kunnen we het vullen met initiële waarden, zodat elk nieuw object direct gegevens bevat.

Objecten zijn misschien wel de handigste containers om gegevens in op te slaan. In PHP helpen objecten ons om de echte wereld te modelleren. Stel dat we een database hebben met informatie over boeken: een boek heeft een auteur, een aantal pagina’s, een uitgever, een editie en een recensie. Om het werken met deze gegevens eenvoudiger te maken, groeperen we ze in een klasse Boek met eigenschappen als auteur, aantal pagina’s, uitgever enzovoort. Zo creëren we objecten die lijken op echte boeken. Dit is bijzonder handig omdat de gegevens van onze websites vaak in tabellen worden opgeslagen — de tabelnamen kunnen we als klassennamen gebruiken, en de kolommen als eigenschappen van de klasse. Daardoor wordt het werken met gegevens veel overzichtelijker.

Laten we de verschillen tussen arrays en objecten nader bekijken aan de hand van voorbeelden.

Mogelijkheden van PHP 5.2 en hoger:

We beginnen met het definiëren van een klasse voor onze objecten. Let op dat “klasse” in het enkelvoud is, terwijl “objecten” meervoud is — dit benadrukt dat we meerdere objecten uit één klasse kunnen maken:

<?php
class book{

}
?>

Met het sleutelwoord class definiëren we een klasse voor toekomstige objecten. Laten we nu objecten van deze klasse maken:

<?php
class book{
  
}

$book1 = new book;
$book2 = new book;
print_r($book1);
print_r($book2);
?>

Met het sleutelwoord new maken we nieuwe objecten van de klasse book. Elk object van een klasse wordt een instantie van de klasse genoemd. In dit geval hebben we twee instanties van de klasse book: $book1 en $book2. Met print_r kunnen we de inhoud van deze objecten op het scherm tonen.

Zoals je ziet, laat PHP zien uit welke klasse het object is gemaakt. Als het object gegevens zou bevatten, zouden die ook worden weergegeven. Laten we nu enkele gegevens toevoegen. We beginnen met het definiëren van de eigenschappen van de klasse.

Vanaf PHP 5.2 worden eigenschappen gedefinieerd met de woorden public, protected of private (het oudere sleutelwoord var wordt ook nog ondersteund). Als je eerder hebt gewerkt met Delphi of C++, zullen deze begrippen bekend klinken — ze werken in PHP vrijwel hetzelfde.

public — maakt eigenschappen en methoden openbaar. Ze kunnen van buiten de klasse worden benaderd.

protected — maakt eigenschappen en methoden beschermd. Ze kunnen alleen binnen de klasse zelf en in afgeleide (kind)klassen worden gebruikt.

private — maakt eigenschappen en methoden privé. Ze zijn alleen binnen de eigen klasse beschikbaar.

Voor nu gebruiken we enkel public voor onze eigenschappen:

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

Nu kunnen we eigenschappen toewijzen aan instanties van de klasse:

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print_r($book1);
print_r($book2);
print '</pre>';

Dit levert één gevuld object en één leeg object op:

Je ziet nu hoe je gegevens aan objecten kunt toewijzen. Laten we nu kijken naar methoden. Zoals eerder gezegd zijn dit functies die binnen de klasse worden aangeroepen. We voegen methoden toe om de waarden van de eigenschappen terug te geven:

<?php
class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
}
$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
print '<pre>';
print $book1->getAuthor() . '<br />';
print $book1->getNumberOfPages() . '<br />';
print $book1->getYear() . '<br />';
print $book1->getPublishingOffice() . '<br />';
print $book1->getEditionNumber() . '<br />';
print '</pre>';
?>

We gebruiken de variabele $this om binnen de klasse naar de huidige instantie te verwijzen. Buiten de klasse werkt $this niet. Laten we nu nog twee methoden toevoegen om de boekgegevens op verschillende manieren weer te geven: als tabel en als ongeformatteerde blokken.

(Hier volgt de rest van de code en uitleg over displayTable() en displayUnformatted().)

Zoals je ziet is objectgeoriënteerd programmeren overzichtelijk en krachtig. In de volgende lessen gaan we dieper in op overerving, constructeurs en meer geavanceerde OOP-technieken.