Basis van Object Georienteerd programmeren in PHP

PDF version

Als je verder wilt gaan met programmeren dan een simpele website, is de kennis van Object geörienteerd programmeren een absolute must. In dit artikel leg ik de basis van het Object geörienteerd programmeren uit met behulp van een programmeertaal die veel beginnende programmeurs redelijk tot goed kennen: PHP. Dit zodat ik me kan focussen op het object georienteerd programmeren zelf en niet de taal zelf.

Wat is een object?

Alvorens het begrip object geörienteerd programmeren uit te leggen, lijkt het mij verstandig om eerst uit te leggen wat een object nu eigenlijk is. Een object is een ‘ding’ dat leeft in het geheugen van de computer. Deze bevat data en verschillende functies om dingen met deze data te kunnen doen. In dit artikel houden we ons bezig met het object ‘Klant’. Een object klant heeft bijvoorbeeld als data een naam, achternaam, adres, postcode, et cetera. Als functionaliteit zou deze klant bijvoorbeeld functies kunnen hebben als getNaam() en getAdres(). Hier kom ik later in dit artikel nog op terug.

Wat is object geörienteerd programmeren?

Object geörienteerd programmeren is een manier van programmeren, waarbij men de code gestructureerd programmeert in een klasse (bouwplan voor een object). Het voordeel hiervan is dat de code die je maakt overzichtelijk is en dus beter onderhoudbaar. Een ander groot voordeel van object georienteerd programmeren is dat je je code op een gemakkelijke manier kunt hergebruiken. Je kunt de klasse Klant bijvoorbeeld voor een factuursysteem gebruiken, maar ook voor een helpdesk.

Door middel van de voorbeelden wordt het ongetwijfeld een stuk duidelijker.

Syntax van een klasse

Om tegen php te zeggen dat je een klasse (class) gaat programmeren, typ je het volgende:

1
2
3
4
5
<?php
class Klant
{
}
?>

Het handigste is om voor iedere class een apart bestand aan te maken. Hierdoor blijft je code nog beter van elkaar gescheiden.

Van klasse naar object

Een klasse is een soort bouwplan voor een object. Van een klasse is er altijd maar een, van een object zijn er vaak meerdere. Zo heb je een klasse Klant en van daaruit kun je verschillende klant-objecten maken. Dat doe je als volgt:

1
2
3
4
5
6
7
8
<?php
  class Klant
  {
  }
 
  $piet = new Klant ( );
  $jan = new Klant ( );
?>

Attributen definieren

In ons voorbeeld willen we dat ons Klant-object verschillende attributen (data) vast kan houden. We beperken ons even tot de naam, achternaam en het adres. In php-code zou dit er zo uit kunnen zien:

1
2
3
4
5
6
7
8
9
<?php
class Klant
{
  private $naam;
  private $achternaam;
  private $straat;
  private $huisnummer;
}
?>

Zoals je misschien wel vermoedt, zijn de variabelen leeg op het moment dat het object aangemaakt wordt. Hoe we er data inkrijgen, leg ik hieronder uit. Het woord ‘private’ betekent dat deze variabele alleen te bereiken is vanuit het Object zelf. Van buitenaf kan niemand dus direct bij de data komen. Wanneer je vanuit een andere klasse bij deze data wilt komen, moet je hiervoor een aparte functie scrhijven. Hier zal ik later op terugkomen. Zelf vind ik dit een veilige manier om je data binnen een object op te slaan. Wil je dat data wel van buitenaf gelezen kan worden, dan kan je je attributen ‘public’ maken.

Ditzelfde geldt voor functies binnen het object. Private functies zijn alleen te benaderen vanuit het object zelf en Public functies kun je van buitenaf aanroepen.

Naast Public en Private is er ook nog een middenweg, namelijk Protected. Deze zul je misschien wel tegenkomen als je verder gaat zoeken op internet, maar voorlopig raad ik aan je te beperken tot Public en Private.

De constructor

De constructor, het woord zegt het eigenlijk al, is de functie die wordt aangeroepen op het moment dat het object gemaakt wordt. Ook kun je in de constructor parameters meegeven waarmee je het object van data kan voorzien. In dit artikel neem ik als voorbeeld alleen het attribuut $naam op de constructor, zodat we de rest via een andere methode kunnen doorgeven aan het object. Maar in de praktijk zou je alle attributen mee kunnen geven in de constructor. Je dient de variabelen dan te scheiden met een komma. Een voorbeeld in php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
class Klant
{
  private $naam;
  private $achternaam;
  private $straat;
  private $huisnummer;
 
  public function __construct ( $nieuweNaam )
  {
     $this->naam = $nieuweNaam;
  }
 
}
?>

De methode __construct ( $nieuweNaam ) wordt dus aangeroepen op het moment dat er een nieuwe Klant-object aangemaakt wordt. Wat er in de __construct gebeurt, is eigenlijk vrij eenvoudig. De private $naam krijgt de waarde die als parameter ( $nieuweNaam ) wordt meegegeven. $this->naam verwijst naar de variabele ‘naam’ in dit object. Simpel gezegd, de naam van het Klant-object wordt hetzelfde als de naam die jij aan het object geeft.

Wanneer je twee klanten/objecten hebt, zal dus slechts één object gewijzigd worden. De volgende code geeft dus twee Klant-objecten met een verschillende $naam.

1
2
3
4
<?php
  $jan = new Klant ( "Jan" );
  $piet = new Klant ( "Piet" );
?>

Functies maken

Aan een object zonder functies heb je niet veel. Hoe kan je anders gegevens ophalen/instellen? In het volgende voorbeeld maak ik een aantal get- en setfuncties. Dat zijn functies om data op te halen uit, of juist te wijzigen in, het object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<?php
class Klant
{
  private $naam;
  private $achternaam;
  private $straat;
  private $huisnummer;
 
  public function __construct ( $nieuweNaam )
  {
     $this->naam = $nieuweNaam;
  }
 
  public function setAchternaam ( $nieuweAchternaam )
  {
     $this->achternaam = $nieuweAchternaam;
  }
 
  public function setStraat ( $nieuweStraat )
  {
     $this->straat = $nieuweStraat;
  }
  public function setHuisnummer ( $nieuwHuisnummer )
  {
     $this->huisnummer = $nieuwHuisnummer;
  }
 
  public function getNaam ( )
  {
    return $this->naam;
  }
 
  public function getAchternaam ( )
  {
    return $this->achternaam;
  }
  public function getAdres ( )
  {
    return $this->straat . " " . $this->huisnummer;
  }
}
?>

Zoals je ziet, zijn dit vrij eenvoudige functies. Als je een object een waarde wilt toekennen, zul je altijd een parameter mee moeten geven, zoals achternaam, straat of huisnummer. Als je data gaat opvragen hoef je geen parameter mee te geven, je vraagt tenslotte data op. Het woord ‘return’ doet wat je waarschijnlijk al vermoedt, het geeft de variabele terug die jij achter het woord hebt neergezet.

De functie getAdres geeft één string terug met daarin de straat en het huisnummer, ofwel het adres. Dit is een mooie demonstratie van de mogelijkheden die object geörienteerd programmeren geeft.

Aan het werk…

Gefeliciteerd, je allereerste klasse is af. Hieronder vind je een voorbeeld hoe je deze klasse zou kunnen gebruiken in een phpscript.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
  require_once "Klant.php"; //Vertel PHP waar hij de klasse Klant kan vinden
 
  $klant1 = new Klant ( "Piet" ); //PHP-syntax om een object aan te maken
  $klant2 = new Klant ( "Jan" ); 
 
  $klant1->setAchternaam ( "Pietersen" );
  $klant2->setAchternaam ( "Klaassen" );
 
  $klant1->setStraat ( "Merellaan" );
  $klant2->setStraat ( "Zwaluwhoeve" );
 
  $klant1->setHuisnummer ( 1 );
  $klant2->setHuisnummer ( 6 );
 
  echo $klant1->getNaam ( ) . " ";
  echo $klant1->getAchternaam ( ) . "<br />";
  echo $klant1->getAdres ( ) . "<br />";
 
  echo $klant2->getNaam ( ) . " ";
  echo $klant2->getAchternaam ( ) . "<br />";
  echo $klant2->getAdres ( ) . "<br />";
?>


Resultaat:
Piet Pietersen
Merellaan 1
Jan Klaassen
Zwaluwhoeve 6

Conclusie

Na het bovenstaande voorbeeld te hebben gezien denk je misschien “Wat een onzin, dit is toch veel te veel code voor vier regeltjes output?”. In het voorbeeld dat ik heb gegeven, heb je hier absoluut gelijk in. Het is waanzin om een heel klein script object geörienteerd te gaan schrijven. Maar stel dat deze klasse onderdeel zou zijn van een enorme CRM-applicatie. Dan zouden we onze Klant-klasse gemakkelijk uit kunnen breiden met allerlei database-functies. We hoeven dan maar een keer de functie te schrijven om de klant-gegevens op te halen en vervolgens kunnen we hem door de hele applicatie heen gebruiken.

Door object geörienteerd te programmeren, wordt een applicatie veel overzichtelijker. We kunnen namelijk de functies met betrekking tot een klant netjes in de klant-klasse stoppen en functies voor een factuur, in een factuur-klasse. Door deze overzichtelijkheid, is het ook veel makkelijker om de applicatie te onderhouden. Je hoeft namelijk geen meters code door te spitten om uiteindelijk bij de fout te komen.

Al met al zie je dus dat het object geörienteerd programmeren dieper gaat dan dat je op het eerste gezicht misschien denkt. Zelf programmeer ik nu anderhalf jaar object geörienteerd en ik vind het een fantastische, geordende manier van programmeren. Hopelijk denk jij hetzelfde na het lezen van dit artikel. Mocht je verder willen studeren over dit onderwerp, zoek dan eens op OO of OOP (Object Oriented Programming).

159 Comments

edwardFebruary 10th, 2015 at 15:47

.

ñïàñèáî!!…

franklinFebruary 10th, 2015 at 16:24

.

ñïàñèáî!!…

TroyFebruary 10th, 2015 at 23:51

.

ñïñ….

JimmyFebruary 11th, 2015 at 00:28

.

ñïñ!!…

FranciscoFebruary 11th, 2015 at 23:54

.

áëàãîäàðåí!!…

walterFebruary 12th, 2015 at 01:06

.

good….

HectorFebruary 12th, 2015 at 09:24

.

ñýíêñ çà èíôó!…

juanFebruary 13th, 2015 at 02:35

.

hello!…

troyFebruary 13th, 2015 at 08:17

.

ñïàñèáî!!…

Leave a comment

Your comment