Static in PHP Classes: maak methodes en properties

We hebben gelezen over classes en de methodes die deze bevatten. Om publieke methodes te kunnen benaderen moeten we een instantie van de class maken.

Er is ook een manier om dit niet te hoeven doen: namelijk static methodes en attributen. Static behaviour is overigens niet iets wat we per se altijd willen nastreven. Het is namelijk niet eenvoudig te testen of uit te breiden. Toch is het de moeite om te benoemen.

We nemen als voorbeeld een class die gemaakt is om bepaalde details van een medewerker op te vragen. We noemen deze Personeelsbestand. Met dit object kunnen we een instantie van een Medewerker maken op basis van een ID.

<?php
class Personeelsbestand {
    public static function getMedewerker($id) {
        // Stel je voor dat we hier een database query doen om de medewerker te vinden
        return new Medewerker($id, "John", "Doe");
    }
}

class Medewerker {
    public $id;
    public $voornaam;
    public $achternaam;

    public function __construct($id, $voornaam, $achternaam) {
        $this->id = $id;
        $this->voornaam = $voornaam;
        $this->achternaam = $achternaam;
    }

    public function getVolledigeNaam() {
        return $this->voornaam . " " . $this->achternaam;
    }
}

$medewerker = Personeelsbestand::getMedewerker(1);
echo $medewerker->getVolledigeNaam(); // Output: John Doe
?>

In dit voorbeeld hebben we een static methode getMedewerker binnen de Personeelsbestand class. Deze methode kan worden aangeroepen zonder een instantie van de Personeelsbestand class te maken.

Static Properties

Naast static methodes kunnen we ook static properties gebruiken. Deze behoren tot de klasse zelf en niet tot een specifieke instantie van de klasse.

<?php
class Teller {
    public static $aantal = 0;

    public function __construct() {
        self::$aantal++;
    }

    public static function getAantal() {
        return self::$aantal;
    }
}

$teller1 = new Teller();
$teller2 = new Teller();
echo Teller::getAantal(); // Output: 2
?>

In dit voorbeeld definiëren we een statische eigenschap $aantal die het aantal gecreëerde objecten van de Teller klasse bijhoudt. De waarde van deze eigenschap wordt gedeeld door alle objecten van de klasse.

Static variabelen in methodes

Statische variabelen behouden hun waarde tussen opeenvolgende aanroepen van de methode waarin ze zijn gedefinieerd. Ze zijn handig voor het bijhouden van statusinformatie binnen een methode.

<?php
class Voorbeeld {
    public function tellen() {
        static $aantal = 0;
        $aantal++;
        echo $aantal;
    }
}

$voorwerp = new Voorbeeld();
$voorwerp->tellen(); // Output: 1
$voorwerp->tellen(); // Output: 2
$voorwerp->tellen(); // Output: 3
?>

In dit voorbeeld behouden we de waarde van $aantal tussen opeenvolgende aanroepen van de methode tellen.

Late Static Binding

Late Static Binding (LSB) in PHP is een krachtige functie die het mogelijk maakt om methoden in een basisklasse dynamisch te binden aan de klasse die ze aanroept. Dit is vooral nuttig wanneer je werkt met complexe hiërarchieën van klassen. Met LSB kun je ervoor zorgen dat methoden de juiste context gebruiken, zelfs wanneer ze worden overschreven in afgeleide klassen.

<?php
class Basis {
    public static function maakObject() {
        return new static();
    }

    public function hallo() {
        return "Hallo vanuit Basis";
    }
}

class Afgeleid extends Basis {
    public function hallo() {
        return "Hallo vanuit Afgeleid";
    }
}

$obj = Afgeleid::maakObject();
echo $obj->hallo(); // Output: Hallo vanuit Afgeleid
?>

In dit voorbeeld zorgt new static() ervoor dat de maakObject methode een instantie van de Afgeleid klasse retourneert in plaats van de Basis klasse.

Waarom static gebruiken?

Static methodes en properties kunnen handig zijn voor:

1. Hulpmethodes: Methodes die geen state nodig hebben van een specifieke instantie.
2. Configuratie: Waarden die gedeeld moeten worden door alle instanties van een klasse.

Beperkingen van static

Hoewel static methodes en properties handig kunnen zijn, hebben ze enkele nadelen:

1. Testbaarheid: Het kan moeilijk zijn om static methodes te mocken voor unit tests.
2. Uitbreidbaarheid: Static methodes kunnen niet worden overschreven door subklassen, wat het moeilijker maakt om functionaliteit uit te breiden.

Gebruik static functionaliteit met mate en alleen wanneer het echt nodig is. Voor de meeste situaties is het beter om instantie-methodes en -properties te gebruiken.

---

Static methodes en properties bieden een manier om functionaliteit te definiëren die niet afhankelijk is van een specifieke instantie van een klasse. Ze zijn nuttig voor hulpfuncties en gedeelde configuratie, maar kunnen testbaarheid en uitbreidbaarheid beperken. Gebruik ze daarom spaarzaam en bewust.