Programmeren in PHP/Klassen PHP4

Uit Wikibooks

[bewerk] Klassen in PHP 4

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
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.

[bewerk] Speciale variabelen

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
class foo
{
    var $foo;
    function setFoo ($foo)
    {
        $this->foo = $foo;
    }
 
    function getFoo ()
    {
        return $this->foo;
    }
}
$foobar = new foo ();
$foobar->setFoo ("barfoo");
echo $foobar->getFoo ();
?>

[bewerk] Speciale functies

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
class foo
{
    var $foo;
    function foo($barfoo)
    {
        $this->foo = $barfoo;
    }
 
    function getFoo()
    {
        return $this->foo;
    }
}
$foobar = new foo ("barfoo");
echo $foobar->getFoo();
?>

[bewerk] Een klasse uitbreiden

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
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.

[bewerk] Functies met dezelfde naam

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
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"
?>

[bewerk] Functieoverroeping

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
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;
?>

De wijzigingen aan deze pagina van voor 15 april 2007 vallen alléén onder de GFDL, en niet onder de CC-BY-SA-licentie. U kunt de inhoud van deze pagina dan ook alleen onder de voorwaarden van de GFDL (her)gebruiken. Niet alle bijdragers van voor 15 april 2007 hebben hun werk vrijgegeven onder de dubbellicentie GFDL&CC-BY-SA. Kijk hier voor meer informatie. Lijst van gebruikers die hun wijzigingen niet hebben vrijgegeven onder beide licenties