Comment fonctionnent les classes et les objets en PHP ?

Question

Accepted Answer

PHP dispose d'un support complet de la **programmation orientée objet** : les classes définissent la structure et le comportement, les objets sont des instances. La POO PHP moderne est propre et riche en fonctionnalités, avec des modificateurs de visibilité, des constructeurs et des commodités comme la promotion des propriétés du constructeur.

## Définir une classe

```php
<?php
class User {
    public string $name;            // typed property
    private int $age;                // visibility: public / private / protected

public function __construct(string $name, int $age) {   // constructor
        $this->name = $name;          // $this refers to the instance; -> accesses members
        $this->age = $age;
    }

public function greet(): string {
        return "Hi, I'm {$this->name}";
    }
}

$user = new User("Ann", 30);     // create an instance
echo $user->name;                 // access a property
echo $user->greet();              // call a method
```

Les classes ont des **propriétés typées**, une méthode `__construct` et des méthodes. `$this` fait référence à l'objet courant, et `->` accède aux propriétés/méthodes (PHP utilise `->`, pas `.`).

## Modificateurs de visibilité (encapsulation)

```php
public    // accessible everywhere
private   // only within THIS class
protected // this class and subclasses
```

## Promotion des propriétés du constructeur (PHP 8 — moins de boilerplate)

```php
class User {
    // declare AND assign properties directly in the constructor signature
    public function __construct(
        public string $name,
        private int $age = 0,
    ) {}
    // equivalent to declaring the properties + assigning them — much less code
}
```

La **promotion des propriétés du constructeur** de PHP 8 élimine le boilerplate répétitif de déclaration puis d'assignation — une grande commodité moderne.

## Membres statiques et constantes

```php
class Counter {
    public static int $count = 0;      // belongs to the CLASS, not instances
    const MAX = 100;                    // class constant

public static function increment(): void {
        self::$count++;                  // access static via self::
    }
}
Counter::increment();                    // call via ClassName::
Counter::MAX;
```

Les membres statiques (syntaxe `::`) appartiennent à la classe elle-même ; les constantes utilisent `const`.

## Pourquoi c'est important

La programmation orientée objet est centrale pour le PHP moderne — les frameworks (Laravel, Symfony) et les bases de code professionnelles sont construits autour des classes, donc comprendre la POO PHP est fondamental pour tout développement PHP sérieux.

Savoir comment définir des classes avec des propriétés typées, des constructeurs et des méthodes, les **modificateurs de visibilité** (`public`/`private`/`protected`) qui imposent l'encapsulation, la syntaxe `$this`/`->`/`::`, et les membres/constantes statiques est une connaissance essentielle du quotidien.

Les commodités modernes méritent une attention particulière — la **promotion des propriétés du constructeur** (PHP 8) réduit dramatiquement le boilerplate et est largement utilisée dans le code actuel, et les **propriétés typées** rendent les classes plus robustes.

La POO PHP moderne est propre et capable (bien loin de la réputation procédurale précoce de PHP), et puisque tous les frameworks et applications PHP modernes sont orientés objet, maîtriser les classes et les objets — y compris la syntaxe spécifique à PHP et les fonctionnalités modernes — est un matériel fondamental et incontournable pour écrire du PHP professionnel.