Ik ben net weer begonnen met het mezelf proberen (via tuts en dergelijke) aan te leren van Object Geörienteerd Programmeren (OOP). Zoals ik het lees moet je het zo zien: De klasse is het overkoepelende van de functies die erin staan.
Zie je de class als een boom, dan vormen alle functies die in de class staan samen in het geheel die boom. (of de eigenschappen daarvan)
Een boom heeft bijvoorbeeld wortels-> Daar zou je een functie voor kunnen maken binnen die classe. Takken -> Ook een functie, bladeren ook, enz..
Als ik het idee goed begrijp zit het zo in elkaar:
<?php
// je begint met een naam van de klasse. In dit geval een boom.
class cBoom{
private $sBladtype;
private $sBladkleur;
private $sBoomtype;
private $iBladaantal;
private $iBoomhoogte;
private $sResultaat;
//wanneer je de boom class aanroept moet er een instantie van een boom gemaakt worden waar we mee verder kunnen werken
function __construct($sBoomtype,$iBoomhoogte){
$this->sBladtype = 'standaard';
$this->sBladkleur = 'groen';
$this->sBoomtype = $sBoomtype;
$this->iBladaantal = 500;
$this->iBoomhoogte = $iBoomhoogte;
$this->sResultaat = 'De boom van het type '.$this->sBoomtype.' heeft een hoogte van '.$this->iBoomhoogte;
return $this->sResultaat;
}
function __destruct(){//maakt het resultaat weer leeg als de klasse is afgesloten
$this->sResultaat = "";
return $this->sResultaat;
}
function kleurblad($sBladkleur){
$this->sResultaat = 'Het is herfst, de bladkleur van de boom is nu '.$sBladkleur;
return $this->sResultaat;
}
function boomgroei($iBoomhoogte){
$this->sResultaat = 'De boom is gegroeid, hij is nu '.$iBoomhoogte.' groot.';
return $this->sResultaat;
}
function bladval($iBladaantal){
$this->sResultaat = 'Door de harde wind is de boom bladeren kwijt. Er zitten nu nog maar'.$iBladaantal.' bladeren aan de boom.';
return $this->sResultaat;
}
}
?>
Via deze class kan ik nu een boom aanmaken en deze laten groeien en dergelijke. Zit ik zo goed met het principe, de opbouw en het idee erachter?
@Jelmer
Ik legde precies hetzelfde als jij doet uit op MSN aan Robert, dat is wel apart.
@Kalle & WJ
Kalle heeft wel een punt naar mijn mening. Want een Boom op zich is niet nuttig: elk type boom heeft totaal andere eigenschappen. Een interface is dus best handig denk ik. Maar misschien is een abstracte klasse die je extend toch wel het beste. Dit is een beetje speculeren, omdat je niet weet of een Boom zelf nuttig is, omdat het eigenlijk een achterlijk voorbeeld is (PHP en bomen gaan niet echt samen). Het is dus maar hoe je het in de praktijk toepast. In mijn optiek heb je de class Boom nooit nodig en ben je altijd bezig met een type boom en dan is een interface juist behoorlijk geschikt (of abstracte klasse dus).
Goed, he is inderdaad qua programmering niet zo'n goed voorbeeld, maar het kan/ kon wel handig zijn om het idee of gevoel te pakken te krijgen. Als je een vergelijking kan maken met iets dat je goed kent, is het gemakkelijker een vergelijking te maken en het idee door te krijgen.
Ik denk dat ik met deze informatie toch eens met een user bezig ga, kijken of ik daar zo een beetje uit kan komen.
Bedankt voor de nuttige opmerkingen, daar heb ik wel wat aan en kan ik heus wel mee verder.
Bij deze een basis opzet:
<?php
// je begint met een naam van de klasse. In dit geval een user.
class cUser{
// daarna declareer je de te gebruiken variabelen
private $sUsername; // username van de gebruiker
private $sPassword; // password van de gebruiker
private $sEmail; // email van de gebruiker
private $sActivationcode; // activatiecode voor het account
private $iLevel; // level van de nieuwe gebruiker
function login(){
//logingedeelte
}
function logout(){
//uitlog gedeelte
}
function activate(){
// activeer het account
}
function sendmail(){
// stuur activatiemail/ gewone mail naar de user
}
function setlevel(){
// de beheerder kan bij users het level wijzigen
}
function subscribe(){
// nieuwe users aanmelden + controle op dubbele username enz.
}
}
Ik vraag me af waar dat voor nodig is Thijs. Bij zowel het aanmelden als het inschrijven komt de username uit een post variabele. Waarom moet je dan een "getUsername()" functie maken?
Er moet denk ik nog wel een "setLoggedin()" of een hele nieuwe class waarin sessies/ cookies gezet kunnen worden.
Verder zat ik nog wel te denken aan een "validate" class, waarin alles komt wat gevalideerd moet/ kan worden.
Je hebt nog geen constructor.
De variabelen worden nergens gezet.
En je functies hebben niet public/protected/private ervoor.
De getters en setters zijn niet nodig als je de variabelen nooit wijzigd. Maar ze zullen een keer ingesteld moeten worden dus als dat niet in de constructor gebeurt moet je wel de setters hebben.
Dat de variabelen nergens worden geset, bedoel je tussen () in de functies?
-> Dat klopt, dat komt nog.. het ging nu om de basis opzet :)
Ik heb nu elke functie ook private gemaakt.. Een constructor hoeft dat niet voor he, omdat die sowiezo al echt in die class hoort?
<?php
// je begint met een naam van de klasse. In dit geval een user.
class cUser{
// daarna declareer je de te gebruiken variabelen
private $sUsername; // username van de gebruiker
private $sPassword; // password van de gebruiker
private $sEmail; // email van de gebruiker
private $sActivationcode; // activatiecode voor het account
private $iLevel; // level van de nieuwe gebruiker
function __construct(){
//set uservariabelen
}
private function login(){
//logingedeelte
}
private function logout(){
//uitlog gedeelte
}
private function activate(){
// activeer het account
}
private function sendmail(){
// stuur activatiemail/ gewone mail naar de user
}
private function setlevel(){
// de beheerder kan bij users het level wijzigen
}
private function subscribe(){
// nieuwe users aanmelden + controle op dubbele username enz.
}
}
Robert, denk dat je niet helemaal doorhebt waar public/private/protected voor is, want op deze manier kan je de functies alleen nog maar via de constructor of via een extended class aanspreken. Niet meer vanuit je procedurele code.
Edit: OMG, ik kon eerst niet eens submitten omdat ik JS met strict errors disabled had :S
Hmmm.. ik zie het WillemJan.. :S Was niet de bedoeling eigenlijk..
Ik zou zo zeggen na wat te hebben gelezen over public/private/protected dat ik de meeste dingen protected kan zetten, en de sendmail function -> Een mail class lijkt me daarvoor wel een betere oplossing, die kan evt. wel vanuit de function sendmail() binnen de user class aangeroepen worden.
de functies login/logout/activate/setlevel/sendmail en subscribe worden allemaal binnen die class gebruikt en zijn dan nog wel via de constructor aanspreekbaar. -> Dus ik zou zeggen protected dan, klopt dat?
