Classes

Zoals jullie allemaal al weten ben ik al een super OOP-verslaafde, en met deze tutorial wil ik anderen ook eraan helpen. :)

OOP?
Engelse afkorting van het engelse woord Object Orientated Programming, en vertaald naar het nederlands: Object Georienteerd Programmeren. Zo zou dus iedereen moet programmeren. :) Het is iets wat je broncode overzichtelijk houdt, en in sommige gevallen ook nog sneller. Het is in ieder geval efficient om met OOP aan de slag te gaan.

Ervaring
Ik verwacht in deze tutorial wel dat je al aardige ervaring met php hebt, want classes zijn niet een bepaald makkelijk onderdeel van php.

Maargoed, genoeg gelult. We gaan nu de kunst van OOP leren...

Intro
Een class is simpel weg een groep variabelen en functies die met die variabelen werken. In een goede class werkt ook alles samen. Bovendien kan, als je het goed doet, een class de overzicht van je broncode een stuk verbeteren.
Een class heeft in ieder geval de volgende syntax:
<?php
class Klassenaam {
var $Variabelenaam;
var $Variabelenaam2 = array(); //je kan er alvast een array van maken
var $Varaibelenaam3 = "een string"; //of een andere waarde toekennen

function Functienaam {
//functie
//functie
//nog meer functie...
}

}
?>
Een class roep je aan door er een object van te maken door middel van
<?php $object = Klassenaam; ?> of <?php $object = Klassenaam(); ?>
Functie roep je aan door <?php $object->functienaam(parameters, parameterss..); ?> en variabelen door <?php $object->variabelenaam; ?>

Praktijk
Laten we eens kijken wat we kunnen doen.
Stel dat we een webwinkeltje hebben. Onze trouwe bezoeker heeft een digitale winkelwagen nodig. En dat is met classes prima te realiseren. Bekijk dit stukje van onze winkelwagen class hieronder eens. Merk trouwens op dat alle elementen van dezelfde klasse met de $this variabele worden aangesproken.
<?php
class wagentje {
var $items = array();

function add_item($artikel_nummer, $aantal) {
if (array_key_exists($artikel_nummer, $this->items)) {
$this->item[ $artikel_nummer ] += $aantal;
} else {
$this->item[ $artikel_nummer ] = $aantal;
}
}
}
?>

Lekker overzichtelijk, efficiënt, en goed samenwerkend.

Waarschuwing
Dingen die je niet moet doen.

1. Je mag een class niet in meerdere bestanden of php blokken opsplitten. Dit zal dus niet werken: <?php
class wagentje {
var $vartje = array();

?> <?php
function functie() {

echo 'Functie gedaan';
}
}
?>
Dit zal echter wel werken:
<?php
class wagentje {
var $vartje = array();

function functie() {
?> <?php
echo 'Functie gedaan';
}
}
?>

2. Je mag geen van je classes stdClass noemen.
Dit omdat deze class al gebruikt wordt door de Zend Engine van PHP.

3. Als je in een php versie lager dan 5 werkt mag je de __sleep en __wakeup functies niet declareren in je class

4. Je mag over het algemeen bij versies lager dan php 5 geen functies hebben die beginnen met __
Het is in ieder geval niet aan te raden.

5. Bij versies vóór php 5 moet je constante var initializers gebruiken.
<?php
class Klasse {
//zal niet werken in php4:
var $date = date('Y');
var $array = array('Klaas', $waarde);
var $stfu = $tsja;
var $owner = 'Klaas ' . 'of' . ' Jan';

//zal wel werken
var $arr = array('Dit', 'Dat', 'Achter', 'Voor');
var $string = "Heeey!";
}
?> Op de volgende pagina ga ik uitleggen hoe je dit probleem toch kan oplossen.

Intro
Constructors zijn functies in je klasse die automatisch worden uitgevoerd als je class een nieuwe instance krijgt (Dus er wordt ergens $X = new Y; gedaan). Een functie wordt pas een constuctor als hij precies dezelfde naam als je class heeft(hoofdlettergevoelig) of als hij __construct heet(vanaf php 5).
Constructors zijn ook de reden waarom sommige classes complete zelfwerkende proggramma's zijn. Heb je geen constructor nodig? Maak er dan toch een aan. Het wordt namelijk altijd aangeraden om toch een constructor in je class te hebben.

Praktijk
Het is niet te moeilijk.
<?php
class klasse {
var $vartje = array();
function klasse() {
$this->functie();
}

function functie() {
echo 'Functie gedaan';
}
}
$obj = new klasse;
?>
Driemaal raden wat dit voor output geeft. Je kan ook variabelen doorgeven aan je constructor. Dat doe je zo:
<?php
class klasse {
var $vartje = array();
function klasse($text, $def = 'Iets', $etext = 'end') {
$this->functie();
echo "\n";
echo $text;
echo "\n";
echo $def;
echo "\n";
echo $etext;
}

function functie() {
echo 'Functie gedaan';
}
}
$obj = new klasse("Heeey!", "Doei!");
?>

Herriner je deze nog?
<?php
class Klasse {
//zal niet werken in php4:
var $date = date('Y');
var $array = array('Klaas', $waarde);
var $stfu = $tsja;
var $owner = 'Klaas ' . 'of' . ' Jan';

//zal wel werken
var $arr = array('Dit', 'Dat', 'Achter', 'Voor');
var $string = "Heeey!";
}
?>
Dit kan je zo doen:
<?php
class Klasse {
var $datum = "";
var $array2 = array();
var $stfu;
var $owner = '';
var $arr = array('Dit', 'Dat', 'Achter', 'Voor');
var $string = "Heeey!";

function Klasse {
global $waarde, $iets;
$this->datum = date('Y')
$this->array2 = array('Klaas', $waarde);
$this->owner = 'Klaas ' . 'of' . ' Jan';
}
}
?>

Intro
Extending is ook iets heel moois van classes. Je kan dan bijvoorbeeld een basis klasse maken waar je andere klassen vanaf leidt. Alle functie variabelen kan je in de nieuwe class gebruiken en overschrijven.

Praktijk
<?php
class A {
var $x = "KLM";

function A () {
echo $x;
$this->blub();
}

function blub() {
echo " zei 'Blub'";
}
}

class B extends A {
var $x = "Air France / KLM";

function blub($text = ' zei \"Blub\"') {
echo $text;
}
}
?>
Als ik de A klasse nu zal aanroepen zal hij
KLM zei 'Blub'
outputten. Als ik B zou aanroepen, gebeurt er niets. Php zal zoeken naar een functie B voor constructor, maar die is er niet, dus dat voert hij niets uit. Php gaat verder met het uitvoeren van de code. Zoals je ziet zijn de variabele $x en de blub() functie overgeschreven. En A() is gewoon aanroepbaar, maar het is geen constructor meer.

:: (Scope resolution operator)
Hoewel hij in PHP 5 meer doet, bestaat hij al vanaf php 4.
Met deze scope operator kan je een functie van een klasse al aanroepen voordat je de klasse zelf hebt geintialleerd. Herriner je de class van de vorige pagina nog?
Ik kan daarmee ook nog A::blub(); of B::blub(); doen, zonder er een object van te maken. Bedenk dat zo'n functie niet van de klasse variabelen zelf gebruik mag maken. Dus er moet simpelweg geen $this in staan.

Parent
Met dit kan je bij extending de oude functie behouden, en er toch iets aan toevoegen. Dus parent::functie wordt dan de functie van de basis klasse, met een beetje van de extend erbij. Dus deze code zal zoals verwacht 'Air France - KLM' outputten: <?php
class A {
function X () {
echo "Air France";
}
}

class B extends A {
function X() {
parent::X();
echo " - KLM";
}
}
$obj = new B;
$obj->X();
?> Note: Net zoals bij parent:: kan je ook self:: gebruiken. Maar alleen om een functie van de extending aan te roepen.

PHP 5
Nu weet je alleen de belangrijkste dingen, de basis, maar als je wat meer ervaren ben kan je naar de nieuwe dingen in php 5 kijken. Ook daar heb ik een tutorial van gemaakt: PHP 5 - Wat is nieuw