et Zend Framework bestaat volledig uit objectgeoriënteerde

Transcriptie

1 et Zend Framework bestaat volledig uit objectgeoriënteerde PHP-code. Om het Zend Framework goed te kunnen begrijpen en te kunnen gebruiken, moet u minimaal de basis van objectgeoriënteerd programmeren (OOP) beheersen. Omdat dit niet direct is gerelateerd aan Zend Framework, hebben we besloten deze stof in deze appendix op te nemen. Indien u het gevoel hebt dat u nog niet volledig thuis bent in de wondere wereld van OOP en ontwerppatronen, raden wij u aan dit hoofdstuk te lezen voordat u zich stort op Zend Framework. Deza appendix behandelt de basisbegrippen van objectgeoriënteerd programmeren. U leert wat een klasse is en wat objecten zijn, hoe u de toegang tot een klasse kunt beperken om beter onderhoudbare en uitbreidbare klassen te schrijven. U leert wat abstracte klassen zijn en hoe u interfaces kunt gebruiken. Verder gaan we in op een aantal ontwerppatronen (design patterns) die van belang zijn voor het goed begrijpen van de werking Zend Framework. Deze appendix hoort bij Leer jezelf PROFESSIONEEL Werken met het Zend Framework, geschreven door Wouter Tengeler en Matthijs van den Bos, uitgegeven door Van Duuren Media (2010), ISBN Copyright 2010 Van Duuren Media

2 2 Appendix A Objectgeoriënteerd programmeren Wat objectgeoriënteerd programmeren (OOP) is De term objectgeoriënteerd programmeren is eigenlijk fout. Een betere term zou eigenlijk klassengeörienteerd programmeren (class oriented programming of COP) zijn. We programmeren namelijk helemaal geen objecten maar we programmeren PHP-code die we door het keyword class vooraf laten gaan. Klassenzijndebestandendieweinonze PHP-scripts includen en waar PHP objecten van kan maken. Objecten zijn de voorwerpen die in het geheugen van de computer staan tijdens het uitvoeren van een script. Het idee om grotere problemen op te delen in kleinere stukken die ieder voor zich eenvoudiger zijn op te lossen, is natuurlijk niet nieuw. Al sinds het begin van de moderne computer rond 1960 besefte men dat het niet mogelijk is om als mens in één keer grote problemen te doorzien. Een probleem is in dit geval een vraagstuk dat moet worden opgelost. Bijvoorbeeld: hoe bouw ik een weblogapplicatie? Door de weblogapplicatie op te delen in hapklare blokken en deze blokken los van elkaar te ontwikkelen en op een later tijdstip met elkaar te integreren, is het een stuk eenvoudiger geworden. Ieder blokje doet zijn kleine deel van de applicatie. Door de blokjes onderling met elkaar te laten communiceren, ontstaat één systeem. Een groot voordeel van het ontwikkelen van kleine blokjes functionaliteit die volledig op zichzelf staan, is dat deze blokjes in andere projecten weer opnieuw gebruikt kunnen worden. Dit hergebruik van klassen is één van de drie speerpunten van objectgeoriënteerd programmeren. De twee andere speerpunten zijn onderhoudbaarheid en leesbaarheid. Een klasse bestaat uit twee onderdelen: gegevens en functionaliteit. De gegevens (of data) wordt bewaard in speciale variabelen

3 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 3 genaamd membervariabelen. Dit zijn variabelen die door alle functies in de klasse kunnen worden gebruikt. De functionaliteit van een klasse manipuleert de gegevens zodat het informatie wordt. Om dit te verduidelijken geven we het volgende voorbeeld: Het getal25zegtinprincipeniets.wewetendat het een getal is en dat we het kunnen opslaan in een variabele van het type integer, maar verder hebben we geen idee wat het kan betekenen. Als dit getal het resultaat is van een functie berekenleeftijd in de klasse Persoon dan krijgen we al een idee wat het getal 25 zou kunnen betekenen. De klasse persoon heeft misschien een variabele geboortedatum. De functie berekenleeftijd kan de huidige datum opvragen en samen met de geboortedatum de leeftijd van een persoon berekenen. De variabelen geboortedatum en huidigedatum zijn gegevens, de leeftijd is informatie. In feite is informatie niets anders dan het in context plaatsen van gegevens. Door gegevens en functionaliteit op logische wijze bij elkaar te plaatsen in een klasse, programmeren we objectgeoriënteerd. De basis van objectgeoriënteerd programmeren Klassen en objecten Klasse Een klasse is de blauwdruk van een object. Deze beschrijft de gegevens die in het object worden bijgehouden en de functionaliteit van het object. In de klasse beschrijven we de werking van een object. De klasse wordt door PHP ingelezen en vertaald (parsed). U kunt zich een klasse voorstellen als een mal in een fabriek waarmee voorwerpen (bijvoorbeeld een fiets of een vaas) worden geperst. De mal bepaalt de vorm van het voorwerp, maar pas als het voorwerp is gemaakt kunt u het gebruiken. Het voorwerp dat uit een klasse wordt gemaakt noemen we in OO-termen een instantie (instance).

4 4 Appendix A Objectgeoriënteerd programmeren Net als in een fabriek kunnen er meer objecten uit dezelfde klasse (mal) worden gemaakt. Al deze objecten hebben dan dezelfde eigenschappen en functionaliteit. Een vaas heeft bijvoorbeeld als eigenschappen een kleur en een materiaal. Pas als er een vaas uit de mal komt krijgen de eigenschappen een definitieve waarde. Het materiaal is dan bijvoorbeeld glas en de kleur is blauw. Een andere vaas (een andere instantie) heeft als materiaal aardewerk en als kleur wit terwijl deze uit dezelfde mal komt. Sommige eigenschappen van een object zijn tijdens de levensduur van het object te wijzigen. U kunt bijvoorbeeld besluiten de vaas een andere kleur te geven door hem te verfen. Andere eigenschappen zijn constant. U kunt de glazen vaas niet plotseling van plastic laten zijn. Eigenschappen van een object noemen we properties. Object en klasse Een object is een instantie van een klasse. Het is alleen in gebruik tijdens het uitvoeren van de PHP-code. Van een klasse kunnen meerdere instanties tegelijk in gebruik zijn. Ieder object heeft een unieke identificatie waarmee het van de andere objecten van hetzelfde type kan worden onderscheiden. Membervariabelen Vanaf het moment dat er een object in het geheugen aanwezig is, zijn de properties beschikbaar in de vorm van membervariabelen. Die variabelen horen specifiek bij het object dat zojuist is gemaakt. We kunnen de membervariabelen van het object benaderen door de volgende constructie: $referentievar->membervar. Als voorbeeld nemen we een vereenvoudigde versie van de BlogPost-klasse die we elders in het boek gebruiken. class BlogPost public $title; public $header; public $body; /** * constructor BlogPost */ public function construct() $this->title = ;

5 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 5 $this->header = ; $this->body = ; public function save() // doe database acties om de gegevens // van een blogpost op te slaan Membervariabele Een membervariabele is een variabele die één op één is gekoppeld aan een object. Een membervariabele is te benaderen door $objectvar->membervariabele. In deze code hebben we een klasse gedefinieerd met daarin drie membervariabelen en twee functies. Het is gebruikelijk (en zelfs zeer aan te raden) om de membervariabelen te definiëren direct na het begin van de klasse maar voor de eerste functie. U kunt membervariabelen herkennen aan het keyword public, protected of private voor de naam van de variabele. Een membervariabele die wordt gedefinieerd zoals in bovenstaande code krijgt nog geen type (zoals alle variabelen in PHP pas een type krijgen als aan deze variabele een waarde wordt toegekend). Het is verstandig de variabelen zo snel mogelijk een waarde van het juiste type te geven. In dit geval gebeurt dat in de functie construct. U ziet dat we een membervariabele altijd benaderen door deze vooraf te laten gaan door de speciale variabele $this met daarachter een pijltje (-> een minteken met direct daarachter een groterdanteken). Omdat een klasse eigenlijk een type is net zoals integer of string, kunnen we meerdere variabelen van hetzelfde type maken. $post1 = new BlogPost(); $post2 = new BlogPost(); $post1 en $post2 zijn nu twee verschillende variabelen van hetzelfde type. Iedere variabele bevat zijn eigen object (instantie). Iedere variabele heeft dus zijn eigen membervariabelen $title, $header en $body. Omdat de namen van de membervariabelen gelijk zijn moeten we tegen PHP vertellen welke $title we willen gebruiken. Daarom is het nodig dat

6 6 Appendix A Objectgeoriënteerd programmeren we de membervariabele vooraf laten gaan door het object waarvan we de variabele willen gebruiken. $post1->title of $post2->title. Methoden We hebben gezien dat een klasse (en dus een object) membervariabelen heeft. In deze variabelen wordt de data van het object opgeslagen. Naast data heeft een object ook nog functionaliteit. De functionaliteit is nodig om de data van het object te manipuleren. We hebben de mogelijkheid om binnen klassen functies te definiëren. Deze functies zijn dan niet globaal zoals gewone functies, maar zijn gekoppeld aan de klasse waar de functie in is geplaatst. Het is de bedoeling dat een functie binnen een klasse alleen data van die klasse manipuleert, daarbij eventueel gebruik makend van lokale variabelen. Een functie binnen een klasse heeft in OO-termen de speciale naam methode. Het verschil tussen een gewone functie en een methode is dus dat hij is gekoppeld aan een klasse terwijl een gewone functie overal vandaan gebruikt kan worden. We kunnen in PHP meerdere methoden met dezelfde naam hebben mits deze in verschillende klassen zijn gedefiniëerd. De functie construct en save van het bovenstaande voorbeeld noemen we dus methoden van de klasse BlogPost. Omdat een methode is gedefinieerd binnen een klasse krijgt deze toegang tot de membervariabelen van die klasse via de $this variabele. Methode Een methode is een functie die binnen een klasse is gedefiniëerd en die toegang heeft tot de data van het object waar de methode bij hoort. Constructor U ziet dat we, nadat een object hebben gemaakt, de membervariabelen een waarde kunnen geven. PHP geeft alle variabelen een standaard waarde (unset). Het nadeel van de waarde unset is dat deze geen type heeft. We willen eigenlijk dat onze objecten altijd gevuld zijn met geldige waarden. Een mem-

7 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 7 bervariabele waar een getal in hoort te staan willen we met een getal initialiseren en een membervariabele die een string hoort te bevatten willen we met een string initialiseren. Het voordeel hiervan is dat we allerlei controles van het type dan niet meer iedere keer hoeven te doen zoals we later zullen zien. Constructor De constructor heeft in PHP 5 altijd de naam construct en wordt automatisch aangeroepen op het moment dat het commando new wordt uitgevoerd. In de constructor kunt u membervariabelen initialiseren en eventueel acties uitvoeren die altijd moeten gebeuren. Destructor De destructor is een magische functie met de naam destruct. Deze wordt automatisch aangeroepen vlak voordat het object uit het geheugen wordt verwijderd. In de destructor kunt u afsluitende acties uitvoeren. PHP kent een speciale methode die automatisch wordt aangeroepen als een object wordt gemaakt. Deze methode wordt de constructor genoemd. In PHP 4 heeft deze methode de naam van de klasse, maar in PHP 5 heeft Zend gemeend de naam te moeten veranderen in construct(). Dit is een zogenaamde magische functie. De constructor is bedoeld om initialisatie van het object uit te voeren. In ons voorbeeld hebben we een constructor opgenomen waarin we alle membervariabelen een beginwaarde geven. Het is ook mogelijk andere acties uit te voeren binnen de constructor. Let op dat de constructorfunctie maar één keer wordt uitgevoerd (namelijk bij het instantiëren van het object) en daarna nooit meer. In de constructor kunt u dus alleen acties doen die éénmalig op het object uitgevoerd moeten worden. PHP 5 kent nog een magische functie die automatisch wordt aangeroepen vlak voordat het object uit het geheugen wordt verwijderd. Deze magische functie heet destruct(). In deze zogenaamde destructor kunt u de nodige opruimacties doen. U kunt bijvoorbeeld gewijzigde data nog snel in de database zetten of een array met veel data netjes opschonen. Het is in PHP mogelijk de constructor en/of de destructor weg te laten. PHP zal dan een standaard constructor of destructor uitvoeren. Deze hebben geen merkbare functionaliteit. Net als bij andere functies is het mogelijk om de constructor parameters mee te geven.

8 8 Appendix A Objectgeoriënteerd programmeren Deze parameters kunnen dan worden gebruikt bij het initialiseren van het object. class BlogPost [...] public function construct($p_title, $p_header, $p_body) $this->title = $p_title; $this->header = $p_header; $this->body = $p_body; [...] U kunt deze parameters meegeven in de regel waar u het object maakt: $post1 = new BlogPost( Een blogpost, Dit is de header, Dit is de bodytekst ); $post2 = new BlogPost( Tweede blogpost, Nog een header, bla bla ); Op deze manier kunt u het object in één keer initialiseren zonder eerst alle membervariabelen expliciet te moeten zetten. Encapsulation Een belangrijk begrip binnen objectgeoriënteerd programmeren is encapsulation ofwel afscherming. Om goede herbruikbare code te schrijven moeten we proberen een object zo onafhankelijk mogelijk te laten zijn. We bedoelen hiermee onafhankelijk van code die buiten de klasse staat. Als een klasse niet gebruik maakt van code buiten de klasse, kunnen we het bestand (iedere klasse krijgt zijn eigen bestand) eenvoudig kopiëren naar een volgend project. We hoeven dan niet bang te zijn dat de code niet meer werkt, want het staat volledig op zichzelf. Dit concept noemen we encapsulation.

9 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 9 Toegang tot variabelen In PHP 4 was het nog niet mogelijk variabelen in een object werkelijk af te schermen van andere code buiten het object. Het werd aan de discipline van de programmeurs overgelaten geen interne variabelen van een object te gebruiken. Met de komst van het nieuwe objectmodel in PHP 5 is het mogelijk variabelen werkelijk fysiek af te schermen. Hiermee hebben we een sterk middel in handen om beter te programmeren volgens de OO-methodiek. Net als veel andere object georiënteerde programmeertalen kent PHP 5 drie verschillende vormen van variabelenafscherming: Private Een variabele die is gedefinieerd met het keyword private kan alleen worden gebruikt binnen de klasse waarin deze variabele is gedefinieerd. Als code buiten deze klasse probeert de variabele direct te benaderen, dan volgt een foutmelding. Protected Een variabele kan protected worden gedefinieerd om aan te geven dat deze alleen binnen de klasse zelf gebruikt mag worden. Het verschil met private ligt in het feit dat de variabele ook in eventuele afgeleide klassen (zie Overerving) gebruikt mag worden. Public Een variabele die public is gedefinieerd (wat de standaard is als er niets wordt opgegeven), is overal te gebruiken. Dus ook buiten de klasse. class BlogPost public $title; private $header; protected $body; [ ]

10 10 Appendix A Objectgeoriënteerd programmeren Als we onze BlogPost-klasse aanpassen en de membervariabelen andere toegangsoort (access level) geven, dan kunnen we bekijken wat de gevolgen van deze verandering zijn voor code van buiten de klasse. $post1 = new BlogPost(); $post1->title = Dit is de titel ; De code werkt nog steeds, omdat de membervariabele title publiek is gedefinieerd. $post1->header = Dit een kopje ; $post1->body = Dit is een bodytekst ; Deze regels geven een PHP-foutmelding. Beide membervariabelen is hun toegang vanaf code buiten de klasse ontzegd. Het s nu dus niet meer mogelijk de membervariabelen direct te benaderen. Setters en getters We hebben gezien hoe we de toegang tot membervariabelen van een object kunnen weigeren voor code buiten het object zelf. Dit is natuurlijk erg handig, maar wat als we de waarde van de membervariabele nu toch willen aanpassen? Het is in de OO-methodiek gebruikelijk om voor alle membervariabelen die van buitenaf een (andere) waarde moeten kunnen krijgen, een speciale methode te schrijven. Normaal gesproken geven we deze methode de naam set met de naam van de property die we willen zetten. Dus bijvoorbeeld settitle, setheader en setbody. We noemen deze speciale methoden setters. Setters zijn zeer eenvoudige functies met maar één doel: Het van buitenaf kunnen aanpassen van de waarde van de bijbehorende membervariabele. public function setheader($header) $this->_header = $header;

11 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 11 _ voor variabelenaam Het is u waarschijnlijk opgevallen dat we de variabele header vooraf hebben laten gaan door een underscore: _. Dit is geen typefout. Het is volgens de Zend Framework-codeerstandaard gebruikelijk om private en protected variabelen te laten beginnen met een underscore. Hiermee wordt duidelijk gemaakt dat deze variabele niet extern toegankelijk is. Een membervariabele die met private (of protected) is gedefinieerd kan helemaal niet worden benaderd, ook niet om de waarde uit te lezen. Als we dus de waarde van een property willen opvragen hebben we ook een methodenodigdiedewaardevandeproperty teruggeeft. Deze methode noemen we een getter. Getter-methoden zien er als volgt uit: public function getheader() return $this->_header; Toegang tot methoden Analoog aan de afscherming van membervariabelen is het ook mogelijk methoden af te schermen in PHP 5. Het is belangrijk alleen die methoden beschikbaar te maken voor code buiten het object die ook werkelijk beschikbaar moeten zijn. In PHP 4 waren alle functies (en methoden) automatisch public. U kunt zich voorstellen dat het soms gewenst is interne methoden af te schermen. class BlogPost... /** * sla gegevens van deze blogpost op in de database void */ public function save() if ($this->isnew()) $this->insert(); else $this->update(); /** * geeft true terug als dit een nieuwe blogpost is, * false als deze al bestaat in de database boolean */

12 12 Appendix A Objectgeoriënteerd programmeren private function isnew() return $this->_new; /** * voegt een nieuw record toe in de database void */ private function insert() // doe database insert /** * update een bestaand record in de database void */ private function update() // doe database update We bekijken de code. We willen de gegevens van een blogpost uiteindelijk in een database opslaan. Het BlogPost-object moet een bepaalde mate van intelligentie bevatten zodat de code die dit object gebruikt eenvoudiger wordt. In dit voorbeeld hebben we een publieke methode save gemaakt. We willen dat de code die een BlogPost-object aanroept niet hoeft te weten of het om een nieuwe blogpost gaat of dat het een bestaande blogpost is. Deze kennis nemen we op in het object zelf. We gebruiken in de code gewoon: $post->save(); Het object zoekt zelf uit of er een insert of een update in de database moet worden gedaan. De code die nodig is om dit te doen is voor de buitenwereld niet van belang. We hebben drie private methoden toegevoegd: isnew, insert en update. Deze methoden worden alleen intern gebruikt en worden dus private gedefinieerd. Zouden we deze

13 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 13 methoden aanroepen van buiten het object, dan krijgen we een PHP-foutmelding. Fatal error: Call to private method BlogPost::insert() from context Overeving (inheritance) Een belangrijk idee achter objectgeoriënteerd programmeren is dat code onderhoudbaar en uitbreidbaar moet zijn. Wat betekent het nu eigenlijk als iets uitbreidbaar is? In principe is alles namelijk uitbreidbaar. In het ergste geval moet u de code opnieuw schrijven om nieuwe functionaliteit toe te voegen aan een bestaande applicatie. Wat we willen bereiken is dat we de structuur van onze code zodanig opzetten dat we nieuwe functionaliteit kunnen inbouwen zonder dat we daarvoor de al bestaande code moeten aanpassen. Nu hangt het natuurlijk van het soort uitbreiding af of dat in de praktijk ook echt lukt, maar met goed gekozen klassen kunnen we de aanpassingen minimaliseren. Als we minder in bestaande code moeten aanpassen, is er ook minder kans dat we nieuwe fouten introduceren. Dat betekent dat we minder code hoeven te debuggen. Dit alles zorgt ervoor dat we in minder tijd de nieuwe functionaliteit kunnen inbouwen waardoor de ontwikkelkostprijs lager kan zijn. Bijna alle programmeertalen die objectgeoriënteerd programmeren ondersteunen zijn uitgerust met een speciaal mechanisme dat we overerving of in het Engels inheritance noemen. Overerving betekent dat we een bestaande klasse kunnen uitbreiden en nieuwe functionaliteit kunnen toevoegen aan de klasse zonder dat we de bestaande klasse moeten aanpassen. We kunnen een klasse uitbreiden (in het Engels extenden) met het keyword extends. De klasse waarvan de uitgebreide klasse is afgeleid noemen we in OO-termen de basisklasse (ook wel parentclass of superclass). De

14 14 Appendix A Objectgeoriënteerd programmeren nieuwe klasse wordt afgeleide klasse, subklasse of childclass genoemd. In code ziet het er als volgt uit: /** * Basisklasse */ class Basisklasse public $naam; public function construct() $this->naam = Basis ; /** * Subklasse */ class Subklasse extends Basisklasse public $extra; public function construct() parent:: construct(); $this->extra = Sub ; // main code $object = new Subklasse(); echo ($oobject->naam. -.$oobject->extra); U ziet dat we te maken hebben met twee klassen, maar in de hoofdcode wordt maar één object gemaakt. We kunnen de membervariabele naam, die uit de Basisklasse komt, gebruiken in de Subklasse. We zeggen dat de membervariabele naam wordt geërfd van de Basisklasse. U ziet dat we in beide klassen een constructor hebben ingebouwd. De constructor in Subklasse overschrijft de constructor van Basisklasse. Daardoor wordt bij het maken van het object alleen de constructor van Subklasse aangeroepen. Hierdoor zou de geërfde membervariabele naam geen initialisatiewaarde krijgen. We moeten in PHP altijd

15 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 15 parent:: We kunnen een methode van een basisklasse aanroepen door voor de naam van de methode het keyword parent op te nemen en daar de speciale operator :: tussen te zetten. Deze operator wordt officieel de scope resolution operator of ook wel scope modifier genoemd. expliciet nog de constructor van de basisklasse aanroepen. Dat kunnen we doen door de speciale constructie parent:: construct(). U hebt waarschijnlijk gezien dat we de membervariabele naam van de basisklasse public hebben gedefinieerd terwijl we in de vorige paragrafen juist gepromoot hebben dat alle membervariabelen private moeten zijn vanwege de encapsulation. Laten we eens kijken wat er gebeurt als we de membervariabelen private maken: class Basisklasse private $_naam; [...] class Subklasse extends Basisklasse private $_extra; [...] We voeren het script weer uit: Notice: Undefined property: Subklasse::$_naam Protected Het keyword protected zorgt ervoor dat een membervariabele of methode wel wordt geërft van de basisklasse, maar dat code buiten de basisklasse en de subklasse toch niet direct bij de membervariabele of methode kan. We krijgen een PHP-notice. PHP vertelt ons dat de membervariabele _naam niet is gedefinieerd in de klasse Subklasse. Dit komt doordat het keyword private ervoor zorgt dat een membervariabele of methode niet wordt geërfd. We proberen nu dus een niet bestaande membervariabele te benaderen. Hoe kunnen we dan ervoor zorgen dat we én deencapsulationinordehoudenéndatwe gebruik kunnen maken van overerving van members? Dit kan door gebruik te maken van het keyword protected in plaats van private. class Basisklasse protected $_naam; [...] class Subklasse extends Basisklasse protected $_extra;

16 16 Appendix A Objectgeoriënteerd programmeren [...] We voeren het script opnieuw uit: Fatal error: Cannot access protected property Subklasse::$_naam Deze foutmelding is een bekende, want die vertelt ons dat we proberen een membervariabele van buitenaf te benaderen terwijl deze is afgeschermd. Deze foutmelding kunnen we oplossen door het gebruik van getters zoals we eerder hebben gezien. Het principe van overerving werkt alleen niet op één niveau van klassen, maar dit kan ook op meerdere niveaus worden gebruikt: /** * SubSubklasse */ class SubSubklasse extends Subklasse protected $_extraextra; public function construct() parent:: construct(); $this->_extraextra = SubSub ; Voegen we deze klasse toe aan de klassen diewealhebben,danhebbenweindeklassenhierarchie een nieuwe subklasse gemaakt die is afgeleid van Subklasse, maar omdat Subklasse van Basisklasse is afgeleid, is SubSubklasse indirect ook van Basisklasse afgeleid. SubSubklasse erft dus alle public en protected members van Basisklasse én van Subklasse.

17 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 17 Abstracte klassen We willen voorkomen dat een programmeur per ongeluk een instantie maakt van de klasse die eigenlijk niet bedoeld is om te instantiëren, maar puur als basisklasse voor andere klassen. Sinds PHP versie 5 hebben we hier de mogelijkheid toe gekregen. We kunnen een klasse abstract definiëren. We maken een klasse abstract door het keyword abstract voor de klassedefinitie te plaatsen. Als we een klasse abstract maken, krijgen we een PHP-foutmelding als we proberen toch een instantie van de klasse te maken. abstract class Basisklasse [...] Abstract Het keyword abstract voor een klasse geeft aan dat deze klasse niet geïnstantieerd kan worden. Het maken van een object van deze klasse geeft een foutmelding. Eventuele subklassen van de klasse kunnen wel geïnstantieerd worden. Fatal error: Cannot instantiate abstract class... We hebben hiermee een krachtig middel in handen om programmeurs in het projectteam te wijzen op een fout in het gebruik van onze klasse. In PHP 4 hadden we deze mogelijkheid niet en moesten we maar hopen dat onze klasse correct gebruikt werd. Er is nog een reden om een klasse abstract te definiëren. Soms willen we dat alle afgeleide klassen (subklassen) van een klasse een bepaalde methode bevatten. Alleen hebben alle afgeleide klassen een totaal andere invulling van die methode. We kunnen in de basisklasse geen algemene invulling aan die methode geven omdat er geen algemene invulling is. We willen verplichten dat iedere afgeleide klasse zelf zijn eigen versie van die methode maakt. Dit kunnen we doen door in de basisklasse een methode op te nemen en deze abstract te definiëren.

18 18 Appendix A Objectgeoriënteerd programmeren Abstracte methoden We kunnen een methode van een klasse ook vooraf laten gaan door het keyword abstract. Het wil dan zeggen dat deze methode wel aanwezig is, maar geen implementatie heeft. abstract class Basisklasse protected $_naam; public function construct() $this->_naam = ; public abstract function basismethode(); Merk op dat er direct na het laatste haakje een puntkomma staat. Het hele blok met code tussen accolades is weggelaten. Hiermee vertellen we PHP dat er wel een methode met de naam basismethode is, maar dat de implementatie van deze methode wordt overgelaten aan een subklasse van deze klasse. Abstracte methode Als u een methode abstract definieert, bent u verplicht de implementatie (de code tussen de accolades) volledig weg te laten. class Subklasse extends Basisklasse protected $_extra; public function construct() parent:: construct(); $this->_extra = ; Deze code toont een nieuwe klasse afgeleid van Basisklasse. In deze klasse zijn we vergeten de methode basismethode op te nemen. In de volgende regels wordt een instantie gemaakt van de nieuwe klasse. Voerenwedezecodeuit,dankrijgenwedevolgende foutmelding:

19 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 19 require_once( Basisklasse.php ); require_once( Subklasse.php ); $object = new Subklasse(); $object->basismethode(); Fatal error: Class Subklasse contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Basisklasse::basismethode) Deze foutmelding kan soms wat verwarring opleveren. Vooral het deel... and must therefore be declared abstract... is onduidelijk. In ons geval is de tekst...implement the remaining methods (Basisklasse::basismethode)... van belang. Deze tekst geeft aan dat we vergeten zijn een methode die in de basisklasse abstract is gedefinieerd, te implementeren. Dat is precies de melding die we verwachtten. Wat betekent dan het eerste deel? Dit is eigenlijk heel eenvoudig als u bedenkt dat een klasse pas geïnstantieerd kan worden als alle methoden die zijn gedefinieerd een invulling hebben. Een abstracte methode heeft geen invulling (er staat geen code tussen ). Een klasse met een abstracte methode kan dus nooit geïnstantieerd worden. We hebben gezien dat de enige manier om te forceren dat een klasse niet geïnstantieerd kan worden, is door de klasse zelf abstract te definiëren. De foutmelding geeft ons dus twee mogelijkheden om de fout op te lossen: Maak een methode met de naam basismethode en implementeer deze. Definieer deze nieuwe klasse zelf als abstract, zodat het niet geïnstantieerd kan worden. Let op dat we het probleem in oplossing twee eigenlijk verleggen naar eventuele subklassen van de klasse. De correcte code van de Subklasse zou als volgt kunnen zijn: class Subklasse extends Basisklasse

20 20 Appendix A Objectgeoriënteerd programmeren protected $_extra; public function construct() parent:: construct(); $this->_extra = ; public function basismethode() echo ( METHOD ); Abstracte klasse Als een klasse minimaal één abstracte methode bevat, moet u de klasse zelf abstract definiëren. Dit is om te voorkomen dat u een klasse instantieert waarin nog methoden bestaan zonder implementatie. Interfaces In de vorige paragraaf hebben we geleerd dat we abstracte klassen kunnen gebruiken om te zorgen dat alle programmeurs in het ontwikkelteam het object op de juiste manier gebruiken. We maken de afspraak dat een klasse zelf niet gebruikt wordt als object, maar alleen om als basis voor andere klassen te dienen. Door het keyword abstract krijgt de programmeur die deze afspraak per ongeluk vergeet vanzelf een foutmelding. Dit bevordert de robuustheid van onze code waardoor we achteraf minder tijd kwijt zijn met het zoeken naar lastige bugs. De term interface zal u misschien iets zeggen. Meestal wordt deze geassocieerd met de gebruikersinterface (User interface). Eigenlijk wil de term interface niets anders zeggen dan de mogelijkheid om met een voorwerp (of persoon) te communiceren. Een gebruikersinterface beschrijft hoe u als mens met een computerprogramma kunt communiceren. Op dezelfde wijze communiceren objecten in uw PHP-code ook onderling. Deze vorm van communiceren verloopt door het aanroepen van methoden van een object. Als een object een methode van een ander object aanroept, dan communiceren deze twee objecten met elkaar. Een interface kunnen we beschrijven als de methoden die de objecten van elkaar kunnen aanroepen. Klasse-interface De interface van een klasse is de verzameling van publiek gedefinieerde membervariabelen en methoden van die klasse.

21 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 21 Waarom is een interface zo belangrijk? Interface en klassen aanpassen Als u de interface van een klasse wijzigt, moeten andere klassen die gebruik maken van de gewijzigde klasse ook aangepast worden. Dit moet u zo veel mogelijk voorkomen. Als u klassen ontwerpt, dan bedenkt u hoe deze klassen door andere klassen gebruikt kunnen worden. U bedenkt de namen van de methoden en welke parameters deze methoden moeten krijgen. U bedenkt ook wat voor waarde een methode kan retourneren. Als goed OO-ontwerper weet u dat u membervariabelen niet publiek moet maken, maar dat u in plaats daarvan setters en getters definieert. U gebruikt misschien de magische methoden set() en get() om properties te definiëren. Deze properties zijn ook onderdeel van de interface omdat ze van buitenaf benaderd kunnen worden. Als u een methodenaam of propertynaam tijdens de implementatie van de applicatie wilt veranderen, heeft dat grote gevolgen. Andere klassen maken immers gebruik van deze namen en de programmeurs die deze klassen hebben geschreven zullen het u niet in dank afnemen als u besluit de namen aan te passen. Zij moeten dan namelijk ook hun code wijzigen zodat de namen weer overeenkomen. Om te voorkomen dat u vaak de interface van een klasse moet wijzigen, moet u vooraf goed over deze interface nadenken. Dat doet u door de software gedegen te ontwerpen. Hebt u eenmaal een interface bedacht dan communiceert u de interface met de andere ontwikkelaars in het team. Deze kunnen dan uw klasse gebruiken zonder dat uw klasse volledig geïmplementeerd hoeft te zijn. Hierdoor kunt u de applicatie parallel ontwikkelen met meer programmeurs tegelijk. Veel objectgeoriënteerde programmeertalen kennen de interface ook als speciale klasse. Ook PHP versie 5 heeft het keyword interface geïntroduceerd. Door een interfaceklasse maakt u de afspraak dat alle klassen die de interface implementeren, zich houden aan de namen van de methoden die in de interface gedefinieerd staan.

22 22 Appendix A Objectgeoriënteerd programmeren Om dit te verduidelijken nemen we een voorbeeld uit onze webshop. De klasse BlogList bevat een lijst met BlogPost objecten. Welke blogposts er in de lijst staan, hangt af vandequerydieweopdedatabasehebben gedaan. Het is voor de code die gebruik maakt van het BlogList-object niet interessant om te weten hoe de lijst tot stand komt, maar wel dat de lijst BlogPost objecten bevat. Een BlogList gebruiken we meestal om gegevens uit de lijst te halen en van iedere BlogPost in de lijst bijvoorbeeld iets af te drukken. Stel we willen de BlogList gebruiken om een HTML-tabel te maken met de titels van alle blogposts in de lijst. Normaal gesproken zouden we een array gebruiken met een foreach-statement om de HTML-tabel te genereren. Maar de BlogList is een object en deze kunnen we niet zomaar gebruiken in een foreach-statement. Om onze code schoon en leesbaar te houden zouden we de volgende code willen gebruiken: $list = new BlogList(); // vul de lijst met posts $list->populate(); // genereer een HTML-tabel echo( <table border="1"> ); foreach ($list as $post) echo( <tr><td>.$post->gettitle(). </td></tr> ); echo( </table> ); In deze code instantiëren we een BlogListobject die we vullen (met voorlopig dummy post objecten). We maken een foreach-lus waarin we het BlogList-object gebruiken alsof het een array is. Als we deze code uitvoeren krijgen we geen foutmelding. Dit komt omdat PHP toestaat dat we foreach op een object uitvoeren, maar er gebeurt ook niets. Het BlogList-object is immers geen echte array. Het foreach-statement werkt op een zogenoemde Iterator. Een Iterator is een ontwerppatroon dat het mogelijk maakt om elemen-

23 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 23 ten van een lijst langs te lopen. De PHP-array is daar een goed voorbeeld van. PHP biedt de mogelijkheid om zelf objecten te definiëren die zich gedragen als een Iterator. Om een object een Iterator te maken moet deze zich houden aan bepaalde afspraken. Het moet alle methoden die nodig zijn om door een lijst te lopen implementeren. Dit is precies waar een interface voor is bedoeld. Het definieert de methoden die een object verplicht moet bevatten. De Iterator interface in de Standard PHP Library (SPL) is als volgt gedefinieerd: interface Iterator /* Methods */ public function current(); public function key(); public function next(); public function rewind(); public function valid(); Interface Een interface is een volledig abstracte klasse. Dat wil zeggen dat een interface een klasse is met alle methoden abstract gedefinieerd. Een interface kan alleen publieke methoden bevatten en geen membervariabelen. U ziet dat een interface niets anders is dan een opsomming van de methoden die verplicht aanwezig moeten zijn. Omdat een interface een afspraak is over hoe een object door andere objecten benaderd kan worden, zijn alle methoden van een interface altijd publiek gedefinieerd. Het keyword public mag dan ook weggelaten worden. Als we een klasse een Iterator willen laten zijn, dan moet die klasse aangeven dat het zich houdt aan de afspraken die voor die interface zijn gemaakt. We doen dat door het keyword implements. In onze BlogList zou dat als volgt zijn: class BlogList implements Iterator [...] Net als bij abstracte klassen moet een klasse die een interface implementeert, alle gedefinieerde methoden een invulling geven

24 24 Appendix A Objectgeoriënteerd programmeren (implementeren). Als u dat niet doet, krijgt u een PHP-foutmelding: Fatal error: Class BlogList contains 5 abstract methods and must therefore be declared abstract or implement the remaining methods (Iterator::current, Iterator::next, Iterator::key,...) Als we de BlogList werkend willen maken moeten we de een invulling geven aan de vijf methoden. Dit kan bijvoorbeeld als volgt: class BlogList implements Iterator private $_list; public function construct() $this->_list = array(); /** * voeg een post toe aan de lijst BlogPost $opost void */ public function addpost(blogpost $post) $this->_list[] = $post; /** * vul de lijst met objecten void */ public function populate() // vul de lijst met dummy posts $this->addpost(new BlogPost( Eerste post,, )); $this->addpost(new BlogPost( Tweede post,, )); $this->addpost(new BlogPost( Derde post,, )); $this->addpost(new BlogPost( Vierde post,, )); $this->addpost(new BlogPost( Vijfde post,, )); $this->addpost(new BlogPost( Zesde post,, )); /** * geef het huidige element uit de lijst mixed */

25 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 25 public function current() return current($this->_list); /** * geef de key van het huige element uit de lijst mixed */ public function key() return key($this->_list); /** * geef het volgende element uit de lijst mixed */ public function next() return next($this->_list); /** * zet de interne teller aan het begin van de lijst void */ public function rewind() reset($this->_list); /** * geeft true als het huidige element in de lijst geldig is boolean */ public function valid() return key($this->_list)!== null; In dit voorbeeld hebben we eenvoudigweg gebruikgemaakt van de mogelijkheden van een PHP-array. U ziet dat we in de BlogList een array hebben opgenomen waar de werkelijke BlogPost-objecten in zitten. PHP kent een aantal arrayfuncties die hetzelfde resultaat geven als de functies die we voor onze Iterator nodig hebben. We maken daar dankbaar gebruik van. Alleen de methoden rewind en valid kunnen we niet direct overnemen. De reset-functie geeft hetzelfde

26 26 Appendix A Objectgeoriënteerd programmeren resultaat als de rewind-methode die we willen implementeren. De valid-methode bestaat niet voor een array, dus deze moeten we zelf bedenken. Nadat we de BlogListklasse hebben uitgebreid, kunnen we deze gebruiken alsof het een PHP-array is en kunnen we het foreach-statement gebruiken zoals onze oorspronkelijke wens was. Het resultaat van de foreach is als volgt: <table border="1"> <tr><td>eerste post</td></tr> <tr><td>tweede post</td></tr> <tr><td>derde post</td></tr> <tr><td>vierde post</td></tr> <tr><td>vijfde post</td></tr> <tr><td>zesde post</td></tr> </table> Meer interfaces implementeren In tegenstelling tot overerving is het mogelijk om meer interfaces tegelijk te implementeren. In ons voorbeeld hebben we een klasse geschreven die zich als een gewoon object gedraagt. We kunnen methoden aanroepen als populate en addpost, maar we kunnen het object ook gebruiken alsof het een array is. Nu heeft een gewone array nog een belangrijke eigenschap die onze BlogList niet heeft. We kunnen het aantal elementen van een array opvragen door de functie count() aan te roepen. Om onze BlogList-klasse zich volledig als een array te laten gedragen willen we ook het aantal posts in de lijst kunnen opvragen door middel van de count() functie die PHP ons biedt. Om dit mogelijk te maken is er binnen PHP een andere interface gedefinieerd genaamd Countable. Deze interface is als volgt: interface Countable public function count();

27 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 27 Design by contract We kunnen een interface dus gebruiken om afspraken te maken over welke methoden een klasse moet implementeren. We leggen daarmee in een contract vast welke interface-namen we gaan gebruiken. Dit wordt ook wel design by contract genoemd. U ziet dat de interface maar één methode definieert. Als we de BlogList-klasse Countable maken voegen we de interfacenaam toe aan de implements lijst in de klasse-definitie. Als we de methode count hebben geïmplementeerd hebben we ons aan de afspraak van de interface gehouden en kunnen we de PHP-functie count gebruiken om het aantal elementen in de lijst op te vragen. class BlogList implements Iterator, Countable [...] /** * geeft het aantal elementen in de lijst int */ public function count() return count($this->_list); De code die de HTML-tabel genereert, kunnen we als volgt wijzigen: $list = new BlogList(); // vul de lijst met posts $list->populate(); // genereer een HTML-tabel echo( <table border="1"> ); foreach ($list as $post) echo( <tr><td>.$post->gettitle(). </td></tr> ); echo( <tr><td>.count($list). </tr></td> ); echo( </table> ); Als we deze code uitvoeren, krijgen we netjes een gevulde HTML-tabel met als laatste regel het aantal elementen in de lijst. U ziet dit in de afbeelding. Afbeelding A.1 Resultaat van de code

28 28 Appendix A Objectgeoriënteerd programmeren Final Met het keyword abstract kunnen we dus voorkomen dat een klasse, die niet bedoeld is om direct te instantiëren, door een onnadenkende programmeur in het team toch per ongeluk wordt geïnstantieerd. We dwingen daarmee af dat de programmeur alleen gebruik maakt van een subklasse van de abstracte klasse. Maar wat als we nu het omgekeerde willen bereiken? Stel we hebben een klasse gemaakt die hele specifieke functionaliteit heeft en waarvan we niet willen dat een andere programmeur die functionaliteit kan overschrijven door een eigen klasse te maken die wordt afgeleid van onze klasse. Om dit te bereiken hebben we in PHP 5 het keyword final tot onze beschikking gekregen. We nemen een eenvoudig voorbeeld: final class Finalklasse private $_data; public function construct() $this->_data = ; public function doeiets() // doe iets class SubFinal extends Finalklasse require_once( Finalklasse.php ); require_once( SubFinal.php ); $object = new SubFinal(); Als we bovenstaande code proberen uit te voeren, krijgen we een PHP-foutmelding: Fatal error: Class SubFinal may not inherit from final class (Finalklasse)

29 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 29 Final Door een klasse final te declareren, voorkomen we dat deze klasse afgeleid kan worden. We hebben het dus onmogelijk gemaakt dat deze klasse wordt afgeleid en daarmee belangrijke functionaliteit kan worden overschreven. Final-methoden Het is misschien een beetje overdreven dat de hele klasse niet kan worden overerfd, terwijl misschien alleen een paar methoden zodanig belangrijk zijn dat we niet willen dat iemand een andere implementatie daarvan maakt. In plaats dat we de hele klasse als final definiëren, kunnen we ook alleen een methode het keyword final meegeven. Dat betekent dat alleen die methode niet mag worden overschreven in de subklasse. We veranderen het voorbeeld: class Finalklasse private $_data; public function construct() $this->_data = ; public function doeiets() // doe iets final function speciaal() // deze methode mag niet worden // overschreven in een subklasse class SubFinal extends Finalklasse public function speciaal()

30 30 Appendix A Objectgeoriënteerd programmeren Als we nu de code opnieuw uitvoeren krijgen we een andere foutmelding: Fatal error: Cannot override final method Finalklasse::speciaal() De methode speciaal is nu afgeschermd zodat een afgeleide klasse geen eigen versie van die methode mag hebben. Het nut hiervan ligt in de onderhoudbaarheid. Stel dat de basisklasse een complexe berekening uitvoert die erg cruciaal is (bijvoorbeeld de berekening van een factuurbedrag). We willen zeker weten dat een andere programmeur deze berekening niet per ongeluk fout doet. Door de methode final te maken weten we zeker dat er altijd gebruik gemaakt wordt van onze eigen versie van de methode. Final-methode Door een methode in een klasse final te declareren, kunnen we verbieden dat een afgeleide klasse deze methode overschrijft. Abstract en final gaan niet samen Het is misschien overbodig op te merken dat het keyword abstract en final niet samengaan. Als we een klasse of methode abstract declareren, verplichten we dat deze wordt afgeleid in een subklasse. Als we een klasse of methode final declareren, verbieden we dat deze wordt afgeleid. Klassenvariabelen We hebben gezien dat we in klassen variabelen kunnen maken. Deze membervariabelen horen specifiek bij het object dat uit die klasse wordt geïnstantieerd. Hebben we meer objecten van een klasse, dan hebben we ook meer versies van de membervariabelen. Als een membervariabele protected of private is gedefiniëerd, dan is er geen mogelijkheid om vanuit het ene object bij een membervariabele van een ander object te kunnen komen. Soms is het handig om een membervariabele toegankelijk te maken voor alle objecten van dezelfde klasse. We willen dan niet per instantie van een object een aparte variabele hebben, maar juist één variabele waar alle objecten bij kunnen. We noemen dit een klassenvariabele (in tegenstelling tot een membervariabele). We nemen als voorbeeld de klasse BlogPost. We weten dat het totaal aantal blogposts in onze weblog best groot kan worden. Om te meten hoeveel BlogPost-objecten we tegelijkertijd geïnstantieerd hebben willen we een teller bijhouden. Zouden we dit in een

31 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 31 class BlogPost /** * Totaal aantal BlogPost-objecten in het geheugen int */ private $_nrpostsinuse = 0; [...] membervariabele doen, dan hebben we per object een aparte variabele. public function construct($p_title, $p_header, $p_body) $this->_nrpostsinuse++; [...] [...] class BlogPost /** * Totaal aantal BlogPost-objecten in het geheugen int */ private static $_nrpostsinuse = 0; [...] public function construct($p_title, $p_header, $p_body) self::$_nrpostsinuse++; [...] [...] Deze code levert niet het goede resultaat. We hebben nu voor ieder object van het type BlogPost een eigen membervariabele _ nrpostsinuse. Deze hebben allemaal de waarde 1. Om dit mogelijk te maken hebben we een nieuw keyword static nodig. Met static geven we aan dat de variabele bij de klasse hoort en niet bij het object. Er wordt één variabele gemaakt die door alle objecten wordt gedeeld.

32 32 Appendix A Objectgeoriënteerd programmeren De code geeft een voorbeeld van de declaratie van een klassenvariabele _nrpostsinuse. Door in de constructor deze variabele op te hogen, houden we een teller bij van het aantal Artikelobjecten dat op een bepaald moment in gebruik (lees in het geheugen) is. Let op dat een klassenvariabele niet benaderd wordt met de ingebouwde variabele $this, maar met self. In dit geval dus self::$_nrpostsinuse. De operator :: (de scope modifier) hebben we al eerder gezien bij het aanroepen van parentmethoden. Een (statische variabele) klassenvariabele kan public, private of protected zijn. Dit heeft geen invloed op de werking van de variabele. Dit heeft natuurlijk wel invloed op de toegankelijkheid van de variabele. Willen we een klassenvariabele benaderen van buiten de klasse, dan moeten we de naam van de klasse voor de variabele plaatsen. In ons voorbeeld BlogPost::$_ nrpostsinuse. Dit werkt natuurlijk alleen indien de variabele public is gedefinieerd. In het bovenstaande voorbeeld hogen we wel de teller op als er een nieuw BlogPost-object wordt aangemaakt, maar als een object niet meer wordt gebruikt (hij wordt verwijderd of null gemaakt), dan moeten we de teller ook weer aflagen. De volgende code zorgt daarvoor: class BlogPost [...] public function destruct() self::$_nrpostsinuse ; [...] Self Het keyword self wordt gebruikt om klassenvariabelen vanuit de klasse zelf te benaderen. Dit is vergelijkbaar met het keyword parent. Dollarteken Een klassenvariabele krijgt een dollarteken voor de variabelenaam, maar achter de scope modifier (::). Dus self::$klassenvariabele of Klasse::$klassenvariabele.

33 Leer jezelf PROFESSIONEEL Werken met het Zend Framework 33 Een klassenvariabele wordt geërfd door een subklasse net als een gewone membervariabele. Dit geldt alleen als deze niet private is gedefiniëerd. Statische methoden Soms is het handig een methode in een klasse te implementeren die logisch gezien wel in die klasse thuishoort, maar geen membervariabelen van die klasse gebruikt. Membervariabelen worden pas actief als er van de klasse een instantie wordt gemaakt en er een object bestaat. Een methode die geen membervariabelen gebruikt kan dus ook worden aangeroepen als er helemaal geen instantie van de klasse is. Normaal gesproken is het niet mogelijk een methode van een klasse aan te roepen zonder eerst een object te maken, maar met een speciale constructie is het mogelijk een methode aan te roepen direct op de klasse zelf. We noemen zo n methode een statische methode, omdat hij aan de klasse is gekoppeld in plaats van aan een object. Het principe werkt op exact dezelfde manier als bij klassenvariabelen. We gebruiken ook hier het keyword static. Nu plaatsen we deze in de declaratie van de methode. public static function genereergetal() return mt_rand(); De methode genereert een willekeurig getal. We kunnen deze methode statisch declareren omdat het geen membervariabelen gebruikt en dus geen objectinstantie nodig heeft. Het gebruik van een statische methode komt sterk overeen met het gebruik van een klassenvariabele. Voor een aanroep van de methode van buiten de klasse gebruiken we: Klassenaam::genereerGetal();

34 34 Appendix A Objectgeoriënteerd programmeren En voor de aanroep van de methode vanuit de klasse zelf gebruiken we: self::genereergetal(); Zoals gezegd kunnen we in statische methoden geen membervariabelen gebruiken omdat er geen object van de klasse is geïnstantieerd. Het is wel mogelijk om een klassenvariabele te gebruiken in een statische methode. Een klassenvariabele is immers ook beschikbaar als er geen object is geïnstantieerd. Als we ons voorbeeld van de BlogPost weer nemen, kunnen we een statische methode definiëren die het aantal in gebruik zijnde objecten teruggeeft. Dit is in feite een getter voor een klassenvariabele. Variabelen in statische methoden Het gebruik van membervariabelen in een statische methode is niet mogelijk. Het gebruik van klassenvariabelen binnen een statische methode daarentegen wel. Een klassenvariabele is immers gekoppeld aan de klasse en niet aan een object. class BlogPost [...] public static function getpostsinuse() return self::$_nrpostsinuse; [...] De volgende code maakt het gebruik van de methode duidelijk: require_once( models/blogpost.php ); echo(blogpost::getpostsinuse(). <br/> ); $post1 = new BlogPost( Eerste post,, ); $post2 = new BlogPost( Tweede post,, ); $post3 = new BlogPost( Derde post,, ); $post4 = new BlogPost( Vierde post,, ); $post5 = new BlogPost( Vijfde post,, ); echo(blogpost::getpostsinuse(). <br/> ); $post2 = null; echo(blogpost::getpostsinuse(). <br/> ); unset($post4); echo(blogpost::getpostsinuse(). <br/> ); De uitvoer van de code is: