PHP OOP : Comprendre les méthodes statiques

Une méthode statique est une méthode déclarée avec le mot-clé static qui appartient à la classe elle-même plutôt qu'à un objet créé à partir d'elle. Étant liée à la classe, vous pouvez l'appeler directement avec le nom de la classe et l'opérateur de résolution de portée (::) — sans new.

Ce chapitre explique comment définir et appeler des méthodes statiques, en quoi elles diffèrent des méthodes classiques (d'instance), comment self:: et static:: se comportent en leur sein, et les cas d'usage où les méthodes statiques sont réellement utiles (utilitaires, compteurs et méthodes factory). Si vous découvrez les classes, lisez d'abord Classes et objets PHP.

Que sont les méthodes statiques en PHP ?

Les méthodes ordinaires opèrent sur un objet précis et peuvent accéder à ses données d'instance via $this. Une méthode statique n'a pas de $this — elle n'est liée à aucune instance et ne peut donc travailler qu'avec les arguments passés et les membres statiques de la classe.

Cela fait des méthodes statiques un choix naturel pour les opérations sans état : un calcul qui dépend uniquement de ses entrées, pas de l'état d'un objet particulier. Calculer la moyenne d'une liste de nombres en est l'exemple classique.

class Math
{
    public static function average(array $numbers): float
    {
        return array_sum($numbers) / count($numbers);
    }
}

Pourquoi utiliser des méthodes statiques ?

Le compromis : comme les méthodes statiques ne peuvent pas être surchargées via une référence d'objet normale et ne portent pas d'état d'instance, leur surutilisation rend le code plus difficile à simuler et à tester unitairement. Préférez les méthodes d'instance quand le comportement dépend de l'état de l'objet.

Comment définir et appeler une méthode statique

Ajoutez static avant le nom de la méthode, puis appelez-la avec ClassName::method() :

<?php

class Math
{
    public static function average(array $numbers): float
    {
        return array_sum($numbers) / count($numbers);
    }
}

$average = Math::average([1, 2, 3, 4, 5]);
echo $average; // 3

Le token :: est l'opérateur de résolution de portée — le même que celui utilisé pour les constantes de classe.

self:: vs static:: et l'absence de $this

À l'intérieur d'une méthode statique, vous ne pouvez pas utiliser $this, car il n'y a aucune instance à référencer. Pour accéder à un autre membre statique de la classe, vous utilisez self:: ou static::.

• self:: se résout vers la classe où la méthode est écrite.
• static:: utilise la liaison statique tardive — elle se résout vers la classe réellement appelée à l'exécution, ce qui est important en cas d'héritage.

<?php

class Base
{
    public static function create(): string
    {
        return self::class;   // always "Base"
    }

    public static function make(): string
    {
        return static::class; // the called class
    }
}

class Child extends Base {}

echo Base::create(), "\n";  // Base
echo Child::create(), "\n"; // Base   (self:: is fixed to where it's written)
echo Child::make(), "\n";   // Child  (static:: follows the call)

Utilisez static:: lorsqu'une classe parente définit un comportement que les sous-classes doivent pouvoir rediriger vers elles-mêmes — c'est le fondement du pattern factory ci-dessous. Pour en savoir plus, consultez Héritage PHP.

Méthodes statiques avec propriétés statiques : un compteur

Les méthodes statiques sont souvent associées aux propriétés statiques pour conserver un état partagé entre tous les objets d'une classe.

<?php

class User
{
    public static int $count = 0;

    public function __construct(public string $name)
    {
        self::$count++;
    }

    public static function total(): int
    {
        return self::$count;
    }
}

new User('Ada');
new User('Linus');

echo User::total(); // 2

Remarquez comment total() lit self::$count sans objet — la propriété vit sur la classe, pas sur un User particulier.

Méthodes factory

Une méthode statique qui retourne une nouvelle instance est appelée une méthode factory. Elle offre un moyen nommé et lisible de construire des objets :

<?php

class Temperature
{
    private function __construct(private float $celsius) {}

    public static function fromCelsius(float $c): static
    {
        return new static($c);
    }

    public static function fromFahrenheit(float $f): static
    {
        return new static(($f - 32) * 5 / 9);
    }

    public function celsius(): float
    {
        return $this->celsius;
    }
}

$t = Temperature::fromFahrenheit(212);
echo $t->celsius(); // 100

L'utilisation de new static() (liaison statique tardive) signifie qu'une sous-classe appelant fromCelsius() obtient une instance d'elle-même, pas de Temperature.

Pièges courants

• $this n'est pas disponible. L'utiliser dans une méthode statique provoque une erreur fatale — il n'y a pas d'objet courant.
• Les méthodes statiques et d'instance peuvent partager un nom uniquement entre classes, pas dans une même classe. Au sein d'une classe, chaque nom de méthode est unique.
• Vous pouvez appeler une méthode statique sur un objet ($obj::method() ou même $obj->method()), mais elle s'exécute quand même sans $this. L'appel via $obj-> est autorisé mais trompeur — préférez ClassName::method() pour la clarté.
• L'état statique est global au processus. Un compteur statique est partagé par toutes les instances et persiste pour toute la durée de la requête, ce qui peut surprendre dans du code long ou des tests.

Conclusion

Les méthodes statiques appartiennent à la classe, s'exécutent sans instance et n'ont pas accès à $this. Elles excellent pour les utilitaires sans état, l'état partagé à l'échelle de la classe via des propriétés statiques, et les méthodes factory qui construisent des objets configurés. Utilisez self:: quand vous visez la classe définissante et static:: quand les sous-classes doivent pouvoir rediriger l'appel vers elles-mêmes. Optez pour les méthodes statiques quand le comportement est lié à la classe plutôt qu'à un objet particulier — et préférez les méthodes d'instance dans le cas contraire.

Ensuite, approfondissez votre compréhension avec Propriétés statiques PHP et Constantes de classe PHP.

Pratique