class

Le mot-clé PHP class

Le mot-clé class définit une classe — un modèle qui décrit les données (propriétés) et le comportement (méthodes) partagés par un groupe d'objets. Vous créez ensuite des objets individuels (également appelés instances) à partir de ce modèle avec l'opérateur new. Les classes constituent le fondement de la programmation orientée objet (POO) en PHP : elles vous permettent de regrouper l'état et la logique connexes en une seule unité réutilisable plutôt que de disperser des variables et des fonctions isolées.

Cette page explique comment déclarer une classe, ajouter des propriétés et des méthodes, initialiser des objets avec un constructeur, contrôler l'accès avec des modificateurs de visibilité, partager des données avec des constantes et des membres statiques, et réutiliser le comportement grâce à l'héritage.

Syntaxe

Une déclaration de classe commence par le mot-clé class, suivi d'un nom et d'un corps délimité par des accolades :

<?php

class MyClass {
  // Properties and methods go here
}

Par convention, les noms de classe utilisent le PascalCase (MyClass, BankAccount). Un nom de classe ne peut pas être un mot réservé PHP, et le corps — même vide — doit utiliser des accolades. Définir une classe ne fait rien par elle-même ; elle n'est utile qu'une fois qu'on crée un objet à partir d'elle.

Propriétés et méthodes

Une propriété est une variable qui appartient à un objet. Une méthode est une fonction qui appartient à une classe. À l'intérieur d'une méthode, la variable spéciale $this fait référence à l'objet courant, donc $this->name lit (ou écrit) la propriété name de cet objet :

<?php

class User {
  public string $name;          // a property

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

$u = new User();
$u->name = "Ada";               // set the property on this object
echo $u->greet();               // Hi, I'm Ada

Notez la flèche -> (et non .) pour accéder aux membres, et que vous écrivez $this->name, jamais $this->$name.

Le constructeur

Définir chaque propriété à la main est verbeux et source d'erreurs. La méthode __construct() s'exécute automatiquement lors de la création d'un objet, vous permettant d'exiger et d'assigner des valeurs initiales en une seule étape. Les arguments que vous passez à new sont transmis au constructeur :

<?php

class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function describe(): string
  {
    return "{$this->year} {$this->make} {$this->model}";
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo $myCar->describe();   // 2022 Ford Mustang

Consultez le constructeur PHP pour plus de détails, notamment sur la promotion des propriétés dans le constructeur.

Visibilité

Chaque propriété et méthode possède une visibilité qui contrôle où elle peut être accédée :

• public — accessible de partout (valeur par défaut si omise).
• protected — accessible uniquement dans la classe et ses sous-classes.
• private — accessible uniquement dans la classe qui la déclare.

Cacher l'état interne derrière private et l'exposer via des méthodes s'appelle l'encapsulation :

<?php

class BankAccount
{
  private float $balance = 0;     // cannot be touched directly from outside

  public function deposit(float $amount): void
  {
    $this->balance += $amount;
  }

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

$acc = new BankAccount();
$acc->deposit(100);
echo $acc->getBalance();   // 100

Plus de détails dans les modificateurs d'accès PHP.

Constantes et membres statiques

Utilisez le mot-clé const pour les valeurs qui ne changent jamais et le mot-clé static pour les données et méthodes qui appartiennent à la classe elle-même plutôt qu'à un objet particulier. Les deux sont accessibles avec l'opérateur de résolution de portée :: :

<?php

class Circle
{
  const PI = 3.14159;          // class constant
  public static int $count = 0; // shared across all instances

  public function __construct()
  {
    self::$count++;            // increment the shared counter
  }
}

new Circle();
new Circle();

echo Circle::PI;        // 3.14159
echo PHP_EOL;
echo Circle::$count;    // 2

Consultez les constantes de classe PHP et les méthodes statiques PHP.

Héritage

Une classe peut extends une autre pour réutiliser et spécialiser son comportement. L'enfant hérite des propriétés et méthodes du parent, et peut les redéfinir :

<?php

class Animal
{
  public function speak(): string
  {
    return "The animal makes a sound.";
  }
}

class Dog extends Animal
{
  public function speak(): string   // overrides the parent method
  {
    return "The dog barks.";
  }
}

echo (new Animal())->speak();   // The animal makes a sound.
echo PHP_EOL;
echo (new Dog())->speak();      // The dog barks.

Pour une couverture plus approfondie, consultez l'héritage PHP, et pour les classes qui définissent un contrat sans implémentation, les classes abstraites et les interfaces.

Exemple complet

L'exemple exécutable suivant combine un constructeur avec des méthodes getter, et illustre l'héritage avec la redéfinition de méthode :

<?php

// Example 1
class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function getMake()
  {
    return $this->make;
  }

  public function getModel()
  {
    return $this->model;
  }

  public function getYear()
  {
    return $this->year;
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo "Make: " . $myCar->getMake() . PHP_EOL;
echo "Model: " . $myCar->getModel() . PHP_EOL;
echo "Year: " . $myCar->getYear() . PHP_EOL;

// Output:
// Make: Ford
// Model: Mustang
// Year: 2022

// Example 2
class Animal
{
  public function speak()
  {
    echo "The animal speaks.";
  }
}

class Dog extends Animal
{
  public function speak()
  {
    echo "The dog barks.";
  }
}

$myAnimal = new Animal();
$myDog = new Dog();
$myAnimal->speak();
$myDog->speak();

// Output:
// The animal speaks.
// The dog barks.

L'exemple 1 construit des objets avec un constructeur et lit leur état via des getters ; l'exemple 2 montre une sous-classe Dog redéfinissant la méthode speak() héritée d'Animal.

Résumé

• Le mot-clé class définit un modèle ; l'opérateur new crée des objets à partir de lui.
• Les propriétés contiennent les données d'un objet, les méthodes définissent son comportement, et $this fait référence à l'objet courant dans une méthode.
• __construct() initialise un objet lors de sa création.
• public, protected et private contrôlent où les membres peuvent être accédés.
• const et static appartiennent à la classe elle-même ; accédez-y avec ::.
• extends permet à une classe d'hériter du comportement d'une autre et de le redéfinir.

Pour une vue d'ensemble de la façon dont ces éléments s'assemblent, consultez les classes et objets PHP.

Pratique