Oop in PHP 5

Vind het een beetje een apart voorbeeld, misschien kan je beter een User class maken (of iets anders waar je wat mee kan). Een object is een type net als een array waar je gegevens in kan opslaan. Je functies hebben nu eigenlijk weinig betekenis neem bijv:

<?php
function boomgroei($iBoomhoogte){
        $this->sResultaat = 'De boom is gegroeid, hij is nu '.$iBoomhoogte.' groot.';
        return $this->sResultaat;
}
// wat je eigenlijk wil is iets opslaan in 1 van je instantie variabelen, dus bijv.
public function setBladKleur($sKleur) {
    $this->sBladKleur = $kleur;
}
?>

Nogmaals aan zon soort klasse heb je vrij weinig, probeer iets om te zetten wat je al kan.
class User
eigenschappen:
- username
- email
- niveau
functies
+ verifyLogin()
+ logOut()
+ etc..

en begin direct met PHP 5 dus overal even public/private/protected voor

Meestal wordt returnen __construct en __destroy niks (weet niet zeker of het is toegestaan)

Als je verder niks met die bladeren doet kan het gewoon als variabelen, wil je er ook dingen mee kunnen doen dan maak je er een losse klasse van.
Sinds PHP 5 behoor je gelukkig public/protected/private voor de functies zetten. Hiermee scherm je als het nodig is sommige functies af voor externe aanroep.
Je functies doen op dit moment niks, je moet de variabelen wel zetten met $this->var = newWaarde;
$private $sResultaat is hier een rare variabelen, je gebruikt hem alleen om wat in te zetten en dat direct terug te geven. Dit is niet nodig
<?php
function kleurblad($sBladkleur){
$this->sResultaat = 'Het is herfst, de bladkleur van de boom is nu '.$sBladkleur;
return $this->sResultaat;
}?>

mag ook:
<?php
private function kleurblad($nwBladkleur){
$this->sBladkleur = $nwBladkleur;
return 'Het is herfst, de bladkleur van de boom is nu '.$sBladkleur;
}?>

__destruct is vooral voor het afhandelen van andere zaken (zoals het sluiten van een database verbinding, dingen wijzigen in een ander object etc.), niet voor het leegmaken van de eigen variabelen die zijn daarna toch weg.

Je zit op de goede weg, maar het is nog niet helemaal juist.

Zo gebruik je een member $sResultaat waarin je telkens de eigenschappen van de boom in zet. Dat is echter niet de bedoeling, want die eigenschappen worden nu juist bepaald door de verschillende members in je klasse.

Die members $sResultaat kun je dus uit je klasse halen en derhalve zal je constructor ook niets retourneren. Dat is ook eigenlijk het hele idee van de constructor: die maakt een instantie aan maar hoeft niets te retourneren.

Verder heb je dan de methodes als boomgroei() en bladval(). Ook hier hoor je niet te werken met $sResultaat, maar je hoort de verschillende members te updaten. Bijvoorbeeld:
<?php
function boomgroei()
{
$this->iBoomhoogte += 10;
}
?>
De boom is nu met 10 gegroeid. Elke keer als je deze methode dus aanroept, groeit je boom. Ditzelfde kun je doen met bladval().

De kleurblad methode kun je inderdaad een parameter meegeven, maar wederom pas je dan de betreffende member aan en niet $sResultaat:
<?php
function setBladkleur($sKleur)
{
$this->sBladkleur = $sKleur;
}
?>

Tenslotte voeg je nog een extra methode toe die weergeeft hoe je boom eruit ziet:
<?php
function show()
{
echo 'De boom van het type '.$this->sBoomtype.' heeft een hoogste van '.$this->iBoomhoogte.'. <br/>';
echo 'De kleur van de bladeren is '.$this->sBladkleur.'.';
// etc.
}
?>

@Rik: Ik vind een boom nog niet eens een gek voorbeeld om mee te beginnen hoor. Zo'n klasse heeft temniste betrekking op een realistisch tastbaar object. Dit in tegenstelling tot een user klasse, dat al een stuk abstracter is.

Het illustreert gewoon wat je met OOP kan.

Rik bij OOP spreken we niet van functies maar van methodes.


Wat ik mis in deze klasse is dat ik een nieuwe kleur voor bladeren kan opgegeven echter deze wordt niet opgeslagen behalve dan in resultaat, idem voor de andere eigenschappen.

Verder zal je moet __toString een display van resultaat kunnen doen

Met het boomvoorbeeld bedacht ik ongeveer dit:

<?php
	class boom {
		public $sType;
		public $iHoogte;
		
		public function __construct($sType,$iHoogte = 0) {
			$this->sType = $sType;
			$this->iHoogte = $iHoogte;
		}
		
		public function groei($iLengte) {
			$this->iHoogte += $iLengte;
			return true;
		}		
		
	}
	
	class tak {
		public $iLengte;
		public $memberOf;
		
		public function groei($iLengte) {
			$this->iLengte +- $iLengte;
		}
		
		public function assign(boom &$obj) {
			$this->memberOf = $obj;
		}
	}
	
	class blad {
		public $sKleur;
		public $memberOf;
		
		public function setKleur($sKleur) {
			$this->sKleur = $sKleur;
		}
		
		public function assign(tak &$obj) {
			$this->memberOf = $obj;
		}
	}
	
	$boom = new boom('beuk',5);
		
		$tak = new tak();
		
			$tak->assign($boom);
	
		$bladeren = array();
		for($i=0;$i<10;$i++) {
			$blad = new blad();
			$blad->setKleur('bruin');			
			$bladeren[] = $blad; //Een array met alle bladeren
			$blad->assign($tak);			
		}
	
	
	
	$tak->groei(3);
		
	$bladeren[3]->setKleur('Geel');
	
	$boom->groei(5);
?>

Weet alleen niet precies hoe references werken (A) dus of de & goed staan en of het werkt weet ik niet.

Oké, bedankt alvast.. ik zie dat er een aantal reacties zijn waar ik wel wat mee kan. Ik zal het eens op mijn gemakje doornemen en de boel aanpassen. Ik was er al ooit mee begonnen, vandaar misschien dat ik wel op de goede weg zat. Ik wil er nu echt mee verder en in de nabije toekomst ook systemen op deze basis bouwen.

Heeft er iemand misschien een aanrader qua boek/website die wat verheldering brengt in OOP in PHP5? Het mag van mij zowel Engels of Nederlands geschreven zijn.

Titel: Professional PHP5
Auteurs: Ed Lecky-Thompson, Heow Eide-Goodman, Steven D. Nowicki, Alec Cove
Uitgever: Wrox
ISBN: 0-7645-7282-2

In het engels, uitgebreide behandeling van OOP.
Staat ook in phphulp boeken lib
Wordt wel al redelijke ervaring met PHP verwacht, maar niet persee PHP5

public function assign(tak &$obj) {

Die & mag weg, objecten gaan automatisch by reference in PHP 5 :)

Overigens is jouw opbouw ook precies zoals ik het zou doen, qua idee dan. Verschillende objecten voor manipuleerbare dingen zoals bomen en takken en bladeren,

Je zou voor Beuk, Spar etc. nog een subclass van Boom kunnen gebruiken. Een Beuk is een boom, maar dan iets specifieker.

De klasse AppelBoom zou bijvoorbeeld nog een method dropApple kunnen hebben, een Spar, of een Boom in het algemeen heeft die niet.

Je zou daaruit ook de kleur van tevoren in de klasse Spar kunnen definiëren. Die is voor een Spar immers altijd groen, terwijl een Plantaan ook wel een ander kleurtje krijgt.