Programmeren in PHP/Klassen PHP 4

Uit Wikibooks
Naar navigatie springen Naar zoeken springen

Programmeren in PHP


  1. Inleiding
  2. Een webserver installeren
  3. Syntax
  4. Variabelen
  5. Beslissingsstructuren
  6. Constanten
  7. Rekenen
  8. Loops
  9. Includes
  10. Functies
  11. Gebruikersinvoer
  12. I/O in PHP
  13. Klassen in PHP 4
  14. Klassen in PHP 5
  15. MySQL en PHP
  16. Reguliere Expressies


Klassen in PHP 4[bewerken]

Houd er rekening mee dat PHP 3 niet meer ondersteund wordt! In PHP4 zijn klassen nog niet zo uitgebreid, maar je kan er al wel wat leuke dingen mee doen.

Klassen of objecten zijn in PHP4 niet echt veel meer dan een verzameling functies (ook wel methodes) die toegang hebben tot een speciale variabele: $this. Deze variabele verwijst naar de klasse zelf, met als doel de functies en variabelen in de klasse aan te spreken. Een klasse heeft als voordeel dat je je functies groepeert. Een standaard klasse wordt op de volgende manier gemaakt.

PHP-code:

<?php
class foo
{
    function bar ()
    {
        echo "Bar aangeroepen!";
    }
}

$foobar = new foo ();
$foobar->bar ();
?>

Zoals je ziet wordt er een nieuwe instantie van de klasse gemaakt door middel van het "new" sleutelwoord, waarna de nieuwe instantie in een variabele ($foobar) wordt gestopt. Vanuit deze variabele kun je de functies die in de klasse gedefineerd zijn (in dit geval bar) aanroepen door middel van de "->" operator.

Speciale variabelen[bewerken]

Een PHP4-methode (een functie in een klasse) heeft toegang tot de speciale variabele $this. Een $this wordt altijd gebruikt als je een klassevariabele aanroept, in tegenstelling tot sommige andere programmeertalen waar je $this (of een equivalent) alleen gebruikt als de locale variabele dezelfde naam heeft als de klassevariabele (om naamconflicten tegen te gaan). De $this-variabele is vooral handig als je dezelfde waarde in meerdere functies wil gebruiken. Een $this-variabele gebruiken we zo;

PHP-code:

<?php
class foo
{
    var $foo;
    function setFoo ($foo)
    {
        $this->foo = $foo;
    }

    function getFoo ()
    {
        return $this->foo;
    }
}
$foobar = new foo ();
$foobar->setFoo ("barfoo");
echo $foobar->getFoo ();
?>

Speciale functies[bewerken]

In PHP4 zijn er een paar speciale functies die je je klasse mee kunt geven. De belangrijkste daarvan is de ‘constructor’. Deze functie, die dezelfde naam heeft als de klasse, wordt aangeroepen als je een nieuwe instantie van de klasse maakt. Je kan de constructor parameters meegeven. Een veel voorkomend gebruik is de beginvariabele in een klasse goed te zetten. Meestal gaat dat op de volgende manier.

PHP-code:

<?php
class foo
{
    var $foo;
    function foo($barfoo)
    {
        $this->foo = $barfoo;
    }

    function getFoo()
    {
        return $this->foo;
    }
}
$foobar = new foo ("barfoo");
echo $foobar->getFoo();
?>

Een klasse uitbreiden[bewerken]

Om klassen flexibel en makkelijk te onderhouden kun je een klasse uitbreiden met nieuwe functies. Je hebt dan ook meteen toegang tot de functies van de klasse waar je van erft (de ouderklasse). Dit proces wordt meestal overerven genoemd, omdat de dochterklasse van zijn ouders de functies en variabelen erft. Dit gaat als volgt te werkt:

PHP-code:

<?php
class foo
{
    var $bar;
    function bar ($setBar)
    {
        $this->bar = $setBar;
    }
}

class fooBar extends foo
{
    function foo ()
    {
        return $this->bar;
    }
}

$foo = new fooBar();
$foo->bar ("Barfoo");
echo $foo->foo();
?>

Zoals je ziet heeft de klasse fooBar toegang tot de variabele van foo, en kan hij hier zonder problemen mee overweg.

Functies met dezelfde naam[bewerken]

In veel object georiënteerde programmeertalen kun je binnen dezelfde klasse meerdere functies met dezelfde naam maar een ander aantal parameters definiëren. Dit proces wordt ook wel overroeping genoemd, of in het Engels "overloading". In PHP4 is dit niet zo, maar je kan wel een functie met dezelfde naam erven van de ouderklasse. Deze functie is dan nog alleen bereikbaar in de dochterklasse en enkel aanroepbaar met het "parent"-sleutelwoord. Een voorbeeld:

PHP-code:

<?php
class foo
{
    function bar ($bar)
    {
        return $bar;
    }
}
class foobar extends foo
{
    function bar ($bar)
    {
        parent::bar ($bar . "bar");
    }
}
$foobar = new foobar();
echo $foobar->bar ("foo"); // resultaat: "foobar"
?>

Functieoverroeping[bewerken]

Net schreef ik dat PHP4 geen functieoverroeping kende, maar dit is niet helemaal waar - PHP4 kan in beperkte mate functies overroepen. Dit geldt alleen voor de functies __set, __get en __call waar __call nog helemaal geen nut heeft. Een standaardklasse in PHP4 heeft altijd de functies __get en __set, alleen worden deze meestal door PHP beheerd. De functies worden aangeroepen als je toegang tot een variabele vraagt (van binnen èn buiten de klasse). Dit werkt ongeveer zo:

PHP-code:

<?php
class foo
{
    function __set ($variabele, $waarde)
    {
        $this->$variabele = "bar" . $waarde;
        return true;
    }

    function __get ($variabele, &$waarde)
    {
        if (isset ($this->$variabele))
        {
            $waarde = $this->$variabele . "foo";
            return true;
        }
        else
        {
            return false;
        }
    }
}

overload ("foo"); //speciaal de functie overroepen
$foo = new foo();
$foo->a = "bar";
echo $foo->a;
?>


Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.