Object georienteerd programmeren in PHP

Object georienteerd programmeren (kortweg: OOP) houdt kortgezegd in dat je met klasses werkt. Deze klasses kun je vervolgens hergebruiken waar je het nodig hebt, en scheelt dus een hoop typwerk als je met een groot project of meerdere projecten bezig bent.
Binnen die klasses kan je functies definieren en gebruiken zoals je dat waarschijnlijk nu gewend bent.

Het voordeel van OOP is, zoals gezegd, dat je je classes kunt hergebruiken. Persoonlijk vind ik het het makkelijkst om ze in externe bestanden op te nemen met de extensie *.inc.php. FF tussen haakjes, gebruik als extensie niet alleen *.inc; mocht je een open dir hebben op je site dan kan je de inc gewoon lezen ben ik achter gekomen :s Als je *.inc.php gebruikt weet je voor jezelf dat het een include bestand is, en wordt het voor buitenstaanders een stuk moeilijker om gevoelige informatie uit je bestanden te halen!

Het nadeel van OOP is dat het vooral veel denkwerk vereist (misschien is dat ook wel een voordeel eigenlijk :P). Het is dus van belang dat je vooraf goed uiteenzet hoe je site/applicatie in elkaar steekt, anders ga je gegarandeerd de fout in (tenzij je een genie bent).
Verder brengt OOP je bij kleine projecten waarschijnlijk alleen in de war. Neemt niet weg dat ik deze tut geschreven heb voor iedereen die eens wil beginnen met object georienteerd programmeren. Niet alleen klinkt het stoer, het is mijns inziens ook een leuk opstapje naar de echte OOP programmeertalen zoals C++.

Maar goed, op de volgende pagina zal ik wat codevoorbeeld geven met object georienteerd programmeren, zodat je zelf kan beginnen hierin ;)

Ok, na deze korte en bondige inleiding in OOP zal ik ff wat codevoorbeeld geven. We gaan een klasse schrijven om een verbinding te maken met een MySQL database.

Je begint in OOP met het definieren van een klasse. Dat doe je als volgt

<?php

class connect_db
{

// hier komen later variabelen en functies...

} //sluiten van de klasse
?>

Zoals je ziet, is het maken van een klasse erg makkelijk.
Wat je vervolgens moet doen, is variabelen declareren/initialiseren en functies maken, anders heb je vrij weinig aan je klasse.
In ons simpele voorbeeld voor de verbinding met MySQL hebben we bijvoorbeeld variabelen nodig voor de host, username, password en databasenaam.
Variabelen worden op de volgende wijze gedeclareerd in klassen:
<?php
var $pass;
?>

Als het goed is, heb je tot nu toe het volgende geschreven:
<?php

class connect_db
{
var $host; // je host
var $user; // je gebruikersnaam
var $pwd; // je password
var $db; // naam van de database

// hier komen zometeen de functies
}
?>

Je hebt nu de noodzakelijke variabelen gedeclareerd. De variabelen worden later - binnen de klasse - aangeroepen in de speciale vorm $this->host of $this->pwd.
Nu gaan we de functie schrijven. Allereerst moet er verbinding gemaakt worden met de database:
<?php
function connect()
{
$connection = mysql_connect($this->host, $this->user, $this->pwd) or die ("Error: kon geen verbinding maken met de database!");

/* als er vervolgens verbinding is gemaakt, kan PHP de database selecteren. */

if($connection) //als er verbinding gemaakt is, de database selecteren
{
$select_db = mysql_select_db($this->db) or die ("Error: kon de database niet selecteren!");
}
} //sluit de functie af
?>

Nu heb je dus een uiterst simpele functie geschreven om binnen de klasse verbinding te maken met een database. Je kan in plaats van $connection ook schrijven $this->connection, maar dan moet je hem wel eerst declareren bovenaan bij de andere variabelen.
De functie moet je nog wel binnen de klasse plaatsen. Let erop, dat je ook al waarden kan meegeven aan de variabelen. Dat is vrij logisch eigenlijk. Je hebt nu het volgende.

<?php

class connect_db
{
var $host = "localhost"; // je host
var $user = "db_user"; // je gebruikersnaam
var $pwd = "db_pass"; // je password
var $db = "OOP"; // naam van de database

function connect()
{
$connection = mysql_connect($this->host, $this->user, $this->pwd) or die ("Error: kon geen verbinding maken met de database!");

/* als er vervolgens verbinding is gemaakt, kan PHP de database selecteren. */

if($connection) //als er verbinding gemaakt is, de database selecteren
{
$select_db = mysql_select_db($this->db) or die ("Error: kon de database niet selecteren!");
}
} // sluit de functie af
} // sluit de klasse
?>

Je klasse is nu klaar. Sla hem op als test.php of test.inc.php (als je hem wilt includen in een ander bestand).
Als je hem nu opent in je server, zie je dat er nog vrij weinig gebeurt. Een lege pagina...
Dit komt omdat we alleen maar een klasse geschreven hebben, er zijn nog geen objecten gemaakt. Om een object te maken schrijf je na de klasse, of nadat je het bestand hebt geinclude:

<?php
$obj = new connect_db;
?>

Je maakt dus gewoon een nieuwe variabele, en die wijs je meteen toe met "new" en dan de naam van de klasse die je wil gebruiken.
Je kan controleren of er een object is gemaakt door de ingebouwde functie is_object te gebruiken:
<?php
if(is_object($obj))
{
print ("Object gemaakt");
}else{
print ("Dit is in ieder geval geen object...");
}
?>

Als alles goed is gegaan, heb je dus een object. Vervolgens kun je de in de klasse geschreven functies aanroepen op dezelfde manier zoals je variabelen aanroept binnen de klasse:
<?php
$obj->connect();
?>

Eventueel kun je de functie zo herschrijven dat je hem hier waarden meegeeft ;)
En nu heb je een database verbinding. Testen door een query uit te voeren op je database, en natuurlijk mysql_fetch_object gebruiken he ;)

Zoals je gemerkt hebt, is object georienteerd programmeren niet zo moeilijk. Het voorgaande is erg basic, maar ik denk wel een goede inleiding in het echte werk.
Spoedig zal je al je projecten in klasses en objecten willen maken, dat is bij mij wel zo in ieder geval :P

Omdat ikzelf ook nog niet zo lang OOP programmeer in PHP, kunnen er hier en daar wat foutjes ingeslopen zijn. Verbeter me dan maar :)
En ik heb expres niet gelet op echte foutafhandeling, omdat het niet al te moeilijk moest worden. De bomen...het bos hè :P