Werk je al even met PHP en merk je dat je scripts steeds langer en rommeliger worden? Dan is het tijd om object-oriented PHP te leren. Met object-oriented programming (OOP) organiseer je code rond objecten die zowel data als gedrag bevatten, waardoor grote projecten overzichtelijk en herbruikbaar blijven.
In deze handleiding leer je de fundamenten van OOP in PHP. We behandelen classes, objects, properties, methods, constructors en de belangrijkste toegangsmodifiers. Aan het einde kun je je eigen classes schrijven en begrijp je waarom moderne frameworks als Laravel en Symfony volledig op OOP zijn gebouwd.
Waarom object-oriented PHP leren?
Procedureel programmeren, waarbij je voornamelijk met losse functies en scope werkt, is prima voor kleine scripts. Zodra je project groeit, loop je echter tegen grenzen aan. Gegevens en logica raken verspreid over talloze functies en globale variabelen.
OOP lost dit op door gerelateerde data en gedrag samen te bundelen in één eenheid: een object. Dat maakt je code:
- Overzichtelijker, alle gebruikerslogica staat bijvoorbeeld in één
User-class - Herbruikbaar, dezelfde class kun je in meerdere projecten inzetten
- Testbaar, geïsoleerde objecten zijn makkelijker te unit-testen
- Uitbreidbaar, nieuwe functionaliteit voeg je toe zonder bestaande code te breken
Zonder OOP zou een modern framework simpelweg niet werkbaar zijn. Vrijwel elke professionele PHP-codebase in 2026 is object-oriented.
Classes en objects: de basis
De twee belangrijkste concepten van OOP zijn classes en objects. Een class is een blauwdruk, een object is een concreet exemplaar dat je op basis van die blauwdruk maakt.
Vergelijk het met een koekjesvorm (class) en de koekjes die je ermee steekt (objects). Elke koekje is uniek qua grootte of versiering, maar ze delen dezelfde vorm.
Je eerste class schrijven
Een class definieer je met het keyword class:
class Auto
{
public string $merk;
public string $kleur;
public int $bouwjaar;
}
Deze class heeft drie properties: merk, kleur en bouwjaar. Properties zijn simpelweg variabelen die bij een class horen.
Een object instantiëren
Om een object te maken, gebruik je het new-keyword:
$mijnAuto = new Auto();
$mijnAuto->merk = 'Volkswagen';
$mijnAuto->kleur = 'blauw';
$mijnAuto->bouwjaar = 2023;
echo $mijnAuto->merk; // Volkswagen
De pijl -> gebruik je om properties en methods van een object te benaderen. Dit is anders dan bij arrays en loops in PHP, waar je vierkante haken gebruikt.
Je kunt meerdere objecten van dezelfde class maken, elk met eigen data:
$autoVanKlaas = new Auto();
$autoVanKlaas->merk = 'Toyota';
$autoVanLisa = new Auto();
$autoVanLisa->merk = 'Tesla';
Methods: gedrag toevoegen aan een class
Properties slaan data op, maar een class wordt pas echt krachtig als je ook methods toevoegt. Methods zijn functies die binnen een class leven en toegang hebben tot de properties van dat object.
class Auto
{
public string $merk;
public int $snelheid = 0;
public function versnel(int $extra): void
{
$this->snelheid += $extra;
}
public function remAf(): void
{
$this->snelheid = 0;
}
}
$auto = new Auto();
$auto->merk = 'Renault';
$auto->versnel(50);
$auto->versnel(30);
echo $auto->snelheid; // 80
Let op het magische keyword $this. Binnen een method verwijst $this altijd naar het huidige object. Zo kun je vanuit een method de eigen properties lezen en aanpassen.
De constructor: initialiseren bij aanmaken
Het handmatig instellen van properties na new is omslachtig. Daarvoor bestaat de constructor: een speciale method genaamd __construct die automatisch wordt uitgevoerd zodra je een object aanmaakt.
class Auto
{
public string $merk;
public string $kleur;
public int $bouwjaar;
public function __construct(string $merk, string $kleur, int $bouwjaar)
{
$this->merk = $merk;
$this->kleur = $kleur;
$this->bouwjaar = $bouwjaar;
}
}
$auto = new Auto('Volkswagen', 'blauw', 2023);
echo $auto->merk; // Volkswagen
Constructor property promotion (PHP 8+)
Sinds PHP 8 kun je dit nog compacter schrijven met constructor property promotion. Je declareert en initialiseert properties in één keer:
class Auto
{
public function __construct(
public string $merk,
public string $kleur,
public int $bouwjaar,
) {}
}
$auto = new Auto('Volkswagen', 'blauw', 2023);
Deze moderne syntax wordt steeds vaker gebruikt in professionele codebases. Zie ook de officiële PHP-documentatie over constructor promotion voor alle details.
Toegangsmodifiers: public, private en protected
Niet elke property of method hoeft overal toegankelijk te zijn. PHP kent drie toegangsmodifiers om dit te regelen:
- public, overal toegankelijk, ook van buiten de class
- private, alleen binnen de class zelf bruikbaar
- protected, toegankelijk binnen de class en in subclasses
class Bankrekening
{
private float $saldo = 0;
public function storten(float $bedrag): void
{
if ($bedrag > 0) {
$this->saldo += $bedrag;
}
}
public function getSaldo(): float
{
return $this->saldo;
}
}
$rekening = new Bankrekening();
$rekening->storten(100);
echo $rekening->getSaldo(); // 100
// $rekening->saldo = 99999; // Fout: saldo is private
Door $saldo private te maken, voorkom je dat externe code het saldo direct manipuleert. Alleen via storten() kun je het bedrag verhogen. Dit principe heet encapsulation en is een van de pijlers van OOP.
Static properties en methods
Soms wil je functionaliteit op class-niveau, niet per object. Daarvoor gebruik je het static-keyword:
class Calculator
{
public static function optellen(int $a, int $b): int
{
return $a + $b;
}
}
echo Calculator::optellen(5, 3); // 8
Je roept static methods aan met :: (de scope resolution operator) in plaats van ->. Gebruik static alleen voor functionaliteit die geen objectstate nodig heeft, zoals hulpfuncties.
Een praktisch voorbeeld: gebruiker met validatie
Laten we alles samenvoegen in een realistischer voorbeeld. We bouwen een simpele Gebruiker-class die variabelen, types en control flow combineert met OOP:
class Gebruiker
{
private array $fouten = [];
public function __construct(
public string $naam,
public string $email,
private int $leeftijd,
) {
$this->valideer();
}
private function valideer(): void
{
if (strlen($this->naam) < 2) {
$this->fouten[] = 'Naam is te kort';
}
if (!filter_var($this->email, FILTER_VALIDATE_EMAIL)) {
$this->fouten[] = 'Ongeldig e-mailadres';
}
if ($this->leeftijd < 18) {
$this->fouten[] = 'Minimale leeftijd is 18';
}
}
public function isGeldig(): bool
{
return empty($this->fouten);
}
public function getFouten(): array
{
return $this->fouten;
}
}
$gebruiker = new Gebruiker('Jan', '[email protected]', 25);
if ($gebruiker->isGeldig()) {
echo "Welkom, {$gebruiker->naam}!";
} else {
print_r($gebruiker->getFouten());
}
Dit patroon zie je constant terugkomen in echte applicaties: data verzamelen, valideren, en gedrag beschikbaar maken via methods.
Waar gaat OOP over? Vier kernbegrippen
Veel OOP-theorie wordt samengevat in vier begrippen. Voor nu volstaat een korte kennismaking:
- Encapsulation, data en gedrag bundelen, interne state beschermen met private
- Inheritance, een class laten erven van een andere class met
extends - Polymorphism, verschillende classes kunnen dezelfde interface implementeren
- Abstraction, complexiteit verbergen achter een eenvoudige interface
Deze pijlers werk je uit in gevorderde OOP-tutorials. Voor meer diepgang raden we de PHP-handleiding over OOP aan.
Veelgemaakte fouten bij beginnende OOP-developers
Let bij je eerste stappen in OOP op deze valkuilen:
- Alles public maken, bescherm je interne state met private, tenzij er een goede reden is om het extern toegankelijk te maken
- Te grote classes, houd classes gefocust op één verantwoordelijkheid (Single Responsibility Principle)
- Statische methods overgebruiken, static breekt de voordelen van OOP; gebruik het spaarzaam
- Vergeten types toe te voegen, type-declarations op properties en parameters maken je code robuuster en beter controleerbaar met tools als PHPStan
Voordat je aan OOP begint, is het slim om eerst comfortabel te zijn met de basis. Heb je PHP nog niet draaiend? Check onze handleiding over PHP installatie en je eerste script.
Volgende stappen
Je kent nu de bouwstenen van object-oriented PHP: classes, objects, properties, methods, constructors en toegangsmodifiers. Met deze kennis kun je al serieuze applicaties structureren.
De logische vervolgonderwerpen zijn inheritance (overerving), interfaces, abstract classes en traits. Daarna kom je bij dependency injection en design patterns terecht: de ingrediënten van elke professionele PHP-codebase.
Begin met oefenen: herschrijf een klein procedureel script naar OOP. Maak bijvoorbeeld een Product-class met een prijs, naam en een method om btw te berekenen. Hands-on oefenen is de snelste weg naar vloeiend OOP denken.
Veelgestelde vragen
Wat is object-oriented PHP?
Object-oriented PHP is een programmeerstijl waarbij je code organiseert rond objecten: zelfstandige eenheden die data (properties) en gedrag (methods) combineren. Het maakt grote projecten beter onderhoudbaar en herbruikbaar.
Wat is het verschil tussen een class en een object?
Een class is de blauwdruk of het recept, terwijl een object een concreet exemplaar is dat je op basis van die class maakt. Van één class kun je meerdere objecten instantiëren, elk met hun eigen data.
Wanneer gebruik je OOP in PHP?
Gebruik OOP zodra je project meerdere gerelateerde functies en datastructuren combineert, zoals gebruikers, producten of bestellingen. Voor kleine scripts volstaat procedureel PHP vaak prima.
Wat doet de constructor in PHP?
De constructor (__construct) is een speciale methode die automatisch wordt uitgevoerd zodra je een nieuw object aanmaakt. Je gebruikt hem om beginwaarden toe te kennen aan properties.
Wat betekenen public, private en protected?
Dit zijn toegangsmodifiers die bepalen wie een property of method mag gebruiken. Public is overal toegankelijk, private alleen binnen de class zelf, en protected binnen de class en subclasses.