PHP Academy · Leçon

Propriétés et méthodes statiques

Utiliser des membres statiques et comprendre quand les appeler sans instance.

Propriétés et méthodes statiques est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Introduction : propriétés et méthodes statiques

Les membres statiques appartiennent à la classe elle-même plutôt qu'à une instance particulière. Accédez-y avec ClassName::member ou avec self:: à l'intérieur de la classe. Ils sont partagés par toutes les instances.

Concepts fondamentaux

Concepts clés des propriétés et méthodes statiques :

Déclarez-les avec le mot-clé static
Accédez-y avec :: (opérateur de résolution de portée)
Utilisez self:: à l'intérieur de la classe et ClassName:: depuis l'extérieur
Utilisez la liaison statique tardive avec static::

Propriété statique

Exemple :

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Méthode statique

Suite :

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Modèle singleton

Entraînement :

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Compteur statique

Pour aller plus loin :

<?php
class EventEmitter {
    private static int $instanceCount = 0;

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

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

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Liaison statique tardive

Utilisation avancée :

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Fabrique statique

Modèle concret :

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Compromis entre statique et instance

Bonnes pratiques :

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Modèle pratique

Mettons tout cela en pratique avec un modèle concret pour les propriétés et méthodes statiques.

Pièges courants

Évitez ces erreurs courantes avec les propriétés et méthodes statiques :

Les membres statiques sont partagés par toutes les instances
Préférez la liaison statique tardive (static::) à self:: dans les classes pouvant être héritées
Les singletons sont un modèle courant, mais parfois utilisé à outrance
Les méthodes statiques sont plus difficiles à simuler dans les tests unitaires

Vérification rapide

Quel mot-clé permet d'accéder à une propriété statique à l'intérieur de la classe tout en respectant l'héritage (liaison statique tardive) ?

Récapitulatif : propriétés et méthodes statiques

Vous avez étudié les propriétés et méthodes statiques. Voici les points essentiels à retenir :

Les membres statiques sont partagés par toutes les instances
Préférez la liaison statique tardive (static::) à self:: dans les classes pouvant être héritées
Les singletons sont un modèle courant, mais parfois utilisé à outrance
Les méthodes statiques sont plus difficiles à simuler dans les tests unitaires

Questions Fréquemment Posées

La leçon « Propriétés et méthodes statiques » est-elle gratuite ?

Oui — le texte complet de « Propriétés et méthodes statiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Propriétés et méthodes statiques » ?

Utiliser des membres statiques et comprendre quand les appeler sans instance. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Propriétés et méthodes statiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à PHP Academy