1. Deze website gebruikt cookies. Door deze website verder te gebruiken, gaat u akkoord met ons gebruik van cookies. Leer Meer.

[PHP]Hoe gebruik je classes, de basis

Discussie in 'Webdesign' gestart door pderaaij, 8 jul 2006.

Topicstatus:
Niet open voor verdere reacties.
  1. pderaaij

    pderaaij Guest

    [hand]
    Inleiding

    In deze tutorial ga ik je laten zien wat classes zijn, wat het idee er achter is en hoe je het gebruikt in PHP.

    Ik ga er vanuit dat je PHP5 gebruikt, maar zal ook laten zien wat het verschil is met PHP4. De PHP versies 1 t/m 3 hebben geen ondersteuning voor classes of de ondersteuning is dusdanig slecht dat we deze versies buiten beschouwing houden. Overigens is het draaien op deze versies uiterst onverstandig in verband met grote veiligheidslekken.

    Wat zijn classes?

    Als je om je heen kijkt zie je allerlei objecten. Bomen, auto's, mensen, stoelen, en ga zo nog maar heel lang door. Dit zijn allemaal objecten die uit meerdere objecten bestaan. Een boom is een verzameling van wortels, een stam, takken en bladeren. Toch zeg je niet tegen iemand: "H kijk! Dat is een mooi verzameling van wortels, takken, bladeren en een stam!". Je zegt: "H kijk! Dat is een mooie boom!". We geven dus een verzameling objecten een generieke naam als we het over het geheel hebben.

    In deze context moet je classes ook zien.


    Een class bestaat uit de volgende componenten.
    - De class name
    - De class members
    - De class methods

    De class members zijn de variabelen van de class. In het voorbeeld van een boom zou dat dus de volgende variable kunnen zijn: iAantalTakken (Integer), bWater (Boolean).

    De class methods zijn de functies van de class die bepaalde handelingen kunnen verichten. In het voorbeeld: laatBladerenVallen, neemWaterOp.

    Ook deze logia kun je weer naar het normale leven vertalen. Neem bijvoorbeeld auto rijden. Met het auto rijden heb je een aantal variabelen (members). Snelheid, inhoudBenzineTank, aantalPK, motorInhoud.

    Daarnaast heb je ook een aantal handelingen die je verricht, de methods. Bijvoorbeeld geefGas, gebruikStuur, remAf, schakelVersnelling.

    Om gebruik te maken van classes zijn er twee fases. De eerste fase is het ontwerpen en schrijven van de class, ook wel de definitie en declaratie genoemd. In deze fase schrijf je de functionaliteiten van de class, maar kun je er nog niets mee doen. Hiervoor is er een initialisatie voor nodig.

    Dat is dan ook de tweede fase. Je maakt een object aan die de functionaliteiten van de class bevat. Je kan ook meerdere objecten van dezelfde class maken. Logisch toch? Want er zijn ook vele auto's, bomen en mensen.

    Dan nu in PHP

    Om een class in PHP aan te maken start je met het keyword class gevolgd door de classnaam.

    PHP:
    class classnaam
    {

    }
    Dit werkt op deze manier in alle PHP versies.

    Laten we het voorbeeld van de auto uitwerken in een voorbeeld.

    PHP:
    <?php
    class cAuto
    {
        private 
    $iSnelheid;
        private 
    $iInhoudTank;
        private 
    $sKleur;
        private 
    $sMerk;
        private 
    $bMotorKapot;
        public  
    $sCompilatie;
            
        function 
    __construct($sMerk$sKleur)
        {
            
    $this->iSnelheid     0;
            
    $this->iInhoudTank     50;
            
    $this->sKleur         $sKleur;
            
    $this->sMerk          $sMerk;
            
    $this->bMotorKapot     false;
            
            
    $this->sCompilatie "De kleur van de auto met het merk " $this->sMerk " is "$sKleur;
        }
        
        function 
    __destruct()
        {
            
    $this->sCompilatie "";
        }
        
        public function 
    weergeefData()
        {
            
    $sData  "De snelheid van de auto bedraagt " $this->iSnelheid " km/u.<br>\n";
            
    $sData .= "Er zit nog " $this->iInhoudTank " liter in de tank.<br>\n";
            
    $sData .= "De motor is ";
            
    $sData .= $this->bMotorKapot "<b>kapot</b>" "heel"
            
    $sData .= "<br><br>\n\n";
            
    $sData .= "Het merk is " $this->sMerk;
            
    $sData .= "<br>\nDe kleur is " $this->sKleur;
            
    $sData .= "<br><br>";
            
            return 
    $sData;
        }    
        
        public function 
    geefGas()
        {
            
    $this->iSnelheid += 10;
        }
        
        private function 
    geefGas2()
        {
            
    $this->iSnelheid += 10;
        }
        
        private function 
    staStil()
        {
            
    $this->iSnelheid 0;
        }
        
        public function 
    blaasMotorOp()
        {
            
    $this->bMotorKapot true;
            
    $this->staStil();
        }
    }

    $oAuto = new cAuto("Mercedes""rood");

    echo 
    $oAuto->weergeefData();
    $oAuto->geefGas();
    echo 
    $oAuto->weergeefData();
    $oAuto->blaasMotorOp();
    echo 
    $oAuto->weergeefData();

    // probeer de members ineens te benaderen
    echo $oAuto->sCompilatie;
    ?>
    Goed dan nu de uitleg.

    We maken dus een class aan genaamd cAuto. Ik zet voor ieder object, class of variabele een letter die aangeeft wat voor type het is. Zo is i een integer, c een class en o een object. Dit wordt ook wel de Hongaarse Notatie genoemd.

    Vervolgens maken we de class members aan. Dit zijn dus de variabelen die in heel de class gebruikt kunnen worden en desnoods ook nog buiten de class.

    Je ziet voor de meeste members het keyword private staan. Dit keyword geeft het bereik van de variabelen aan. Er zijn drie 'scopes'.


    • [*]Public
      De member is toegankelijk in de class als mede buiten de class. Overal kun je deze class oproepen en veranderen
      [*]Private
      De member mag alleen maar in de classdeclaratie zelf worden aangepast. Instanties van de class mogen niet bij deze variabelen komen.
      [*]Protected
      Een aparte vorm en is een mix van public en private. Hier kom ik een andere handleiding op terug.

    We hebben dus 6 members, waarvan er n als public is gedefinierd en de overige als private.

    De constructor

    De eerste functie/method die je ziet is een constructor. Dit is een speciale functie die automatisch door PHP wordt aangeroepen als er een object wordt aangemaakt. In de constructor kun je dus allerlei initialisatiewerkzaamheden verrichten zoals het invullen van basisgegevens of door verwijzen naar een aantal functies.

    In ons voorbeeld gebruiken we de constructor om het merk en de kleur in te vullen. Deze krijgen we meegeleverd als de class wordt geinitialiseerd.

    De $this variabele
    Je ziet dat we gebruik maken van de variable $this. Dit is een variabele die standaard door PHP wordt aangemaakt en gevuld. We gebruiken deze variabele om de juiste members te benaderen. Dat heeft een beetje uitleg nodig.

    De stuk code die je nu ziet is de definitie van een class. Hier worden straks objecten van gemaakt. Dit kan er n zijn, maar kunnen er ook meerdere zijn. De $this variabele werkt als een 'verwijzer' en zorgt ervoor dat de juiste variabele bij het juiste object gebruikt wordt.

    De destructor
    De destructor is het tegenovergestelde van de constructor en wordt dan ook aangeroepen bij het verwijderen van het object. Je kunt in deze functie voor het afsluiten nog wat opruimwerkzaamheden verrichten of nog wat informatie in de database of bestand wegschrijven.

    Methodes
    Vervolgens staan er een aantal methodes om de private variabelen weer te geven of aan te passen.

    Ook hier staat er weer het keyword public of private om aan te geven wat het bereik van de method is. Vervolgens komt het keyword function om te melden aan php dat er een functie aankomt. Gevolgd door de naam en de eventuele parameterlijst.

    De werking van de methods spreken vrij voor zich zelf, dus dat laat ik even voor wat het is.

    Object initiantisering

    Nu de class gedefinieerd en gedeclareerd is, kunnen we er echt gebruik van maken. Dat doen we door er een object van te maken.

    De syntax hiervoor is:

    PHP:
    oObjectNaam = new cClassName(parameterlijst);
    in ons voorbeeld word het dus

    PHP:
    oAuto = new cAuto("Mercedes""rood");
    Nu heb je dus een object waarmee je kunt werken.

    Zoals je kunt zien in het voorbeeld maak je aanroep naar functies met behulp van de -> tekencombinatie.

    Je kunt hiermee alleen de public methodes aanroepen. Voeg bijvoorbeeld eens de volgende regel toe in het script.

    PHP:
    $oAuto->geefGas2(); // probeer een private method aan te roepen
    Je zult zien dat je gelijk een mooie error krijgt die het volgende zegt

    Ik maak bewust de keuze om zoveel mogelijk private te houden en maar een paar functies public. Mijn belangrijkste reden is dat op deze manier mijn gegevens beschermd zijn tegen onverwachte overschrijving of verwijdering. Het is veel makkelijker om gegevens te beschermen op deze manier en het debuggen gaat vele malen makkelijker. Daarnaast is het vele malen overzichtelijker om op deze manier je databaseontwerp aanpassingen door te voeren, dan door vele scripts heen te bladeren.

    Tot slot roepen we ook een member direct aan, de compilatie zin was public gedeclareerd en word ook netjes tentoongesteld. Als je probeert om $iSnelheid weer te geven die private declareerd is, zal je een mooie error krijgen.


    Tot slot
    Ik hoop dat dit een kleine handreiking was tot classes in PHP. Mochten er nog vragen zijn, dan hoor ik die graag op het forum.

    Paul de Raaij

    [/hand]
     
    Laatst bewerkt door een moderator: 2 aug 2006
Topicstatus:
Niet open voor verdere reacties.

Deel Deze Pagina