Les objets et classes

Les objets et les classes en PHP vous permettent de créer des modèles de données et de comportement que vous pouvez réutiliser dans vos scripts. Ils sont un élément clé de la programmation orientée objet (POO) et vous aideront à écrire des scripts plus structurés et modulaires.

Voici comment déclarer et utiliser une classe et un objet en PHP :

<?php
  // déclaration de la classe Person
  class Person {
    // déclaration des propriétés (variables de la classe)
    public $name;
    public $age;

    // déclaration du constructeur (méthode appelée lors de la création de l'objet)
    public function __construct($name, $age) {
      $this->name = $name;
      $this->age = $age;
    }

    // déclaration des méthodes (fonctions de la classe)
    public function greet() {
      echo "Bonjour, je m'appelle $this->name et j'ai $this->age ans";
    }
  }

  // création de l'objet $john à partir de la classe Person
  $john = new Person("John", 30);

  // appel de la méthode greet de l'objet $john
  $john->greet(); // affiche "Bonjour, je m'appelle John et j'ai 30 ans"
?>

Les classes

La POO vous permet de modéliser des données et des comportements dans votre code de manière structurée et modulaire.

Une classe est une définition de modèle pour un objet. Elle définit les propriétés (variables) et les méthodes (fonctions) de l’objet. Par exemple, vous pouvez déclarer une classe Person qui définit les propriétés name et age ainsi que la méthode greet :

class Person {
  public $name;
  public $age;

  public function greet() {
    echo "Bonjour, je m'appelle $this->name et j'ai $this->age ans";
  }
}

Les objets

Un objet est une instance de cette classe. Vous pouvez créer plusieurs objets à partir de la même classe en utilisant l’instruction new. Chaque objet a sa propre copie des propriétés et des méthodes de la classe :

$john = new Person();
$john->name = "John";
$john->age = 30;

$jane = new Person();
$jane->name = "Jane";
$jane->age = 25;

$john->greet(); // affiche "Bonjour, je m'appelle John et j'ai 30 ans"
$jane->greet(); // affiche "Bonjour, je m'appelle Jane et j'ai 25 ans"

Les constructeurs

La POO vous permet également de définir des constructeurs et des destructeurs pour vos objets. Le constructeur est une méthode appelée lors de la création de l’objet et qui permet de définir ses propriétés initiales. Le destructeur est une méthode appelée lorsque l’objet est détruit et qui permet de libérer les ressources utilisées par l’objet. Voici un exemple de classe avec un constructeur et un destructeur :

class Person {
  public $name;
  public $age;

  public function __construct($name, $age) {
    $this->name = $name;
    $this->age = $age;
  }

  public function __destruct() {
    echo "L'objet Person $this->name a été détruit";
  }
}

$john = new Person("John", 30);
unset($john); // appelle le destructeur de l'objet $john

Héritage

La POO vous permet également de définir des relations d’héritage entre les classes. Une classe fille hérite des propriétés et des méthodes de sa classe parente et peut en ajouter ou en surcharger. Voici un exemple de classe fille qui hérite de la classe Person :

class Student extends Person {
  public $school;

  public function __construct($name, $age, $school) {
    // appel du constructeur de la classe parente
    parent::__construct($name, $age);

    // définition de la propriété school de la classe fille
    $this->school = $school;
  }

  public function greet() {
    // surcharge de la méthode greet de la classe parente
    echo "Bonjour, je m'appelle $this->name et j'ai $this->age ans. Je suis étudiant à l'école $this->school";
  }
}

$mary = new Student("Mary", 18, "Lycée Joliot-Curie");
$mary->greet(); // affiche "Bonjour, je m'appelle Mary et j'ai 18 ans. Je suis étudiant à l'école Lycée Joliot-Curie"

Méthodes et propriétés de classe

La POO vous permet également de définir des méthodes statiques et des propriétés de classe, qui sont partagées par tous les objets de la classe et qui ne dépendent pas de l’état individuel de chaque objet. Voici un exemple de méthode statique et de propriété de classe :

class Person {
  public static $count = 0; // propriété de classe

  public function __construct() {
    // incrémentation de la propriété de classe
    self::$count++;
  }

  public static function getCount() { // méthode statique
    return self::$count;
  }
}

$john = new Person();
$jane = new Person();
$mary = new Person();

echo Person::getCount(); // affiche 3
echo Person::$count; // affiche 3

Accessibilité des propriétés et des méthodes

En PHP, vous pouvez définir l’accessibilité des propriétés et des méthodes de votre classe en utilisant les mots-clés public, protected et private.

  • public : les propriétés et les méthodes déclarées public sont accessibles de n’importe où dans votre code, y compris depuis l’extérieur de la classe.

  • protected : les propriétés et les méthodes déclarées protected ne sont accessibles que depuis la classe elle-même et depuis les classes filles qui héritent de cette classe.

  • private : les propriétés et les méthodes déclarées private ne sont accessibles que depuis la classe elle-même.

Voici un exemple de classe avec des propriétés et des méthodes de différentes accessibilités :

class Person {
  public $name; // accessible de n'importe où
  protected $age; // accessible depuis la classe elle-même et depuis les classes filles
  private $salary; // accessible uniquement depuis la classe elle-même

  public function __construct($name, $age, $salary) {
    $this->name = $name;
    $this->age = $age;
    $this->salary = $salary;
  }

  public function greet() { // accessible de n'importe où
    echo "Bonjour, je m'appelle $this->name et j'ai $this->age ans";
  }

  protected function getSalary() { // accessible depuis la classe elle-même et depuis les classes filles
    return $this->salary;
  }

  private function setSalary($salary) { // accessible uniquement depuis la classe elle-même
    $this->salary = $salary;
  }
}

Classes abstraites et finales

Vous pouvez également utiliser les mots-clés final et abstract pour empêcher l’héritage ou l’instanciation de certaines classes et méthodes.

  • final : une classe déclarée final ne peut pas être héritée, et une méthode déclarée final ne peut pas être surchargée par une classe fille.
  • abstract : une classe déclarée abstract ne peut pas être instanciée directement et doit être héritée par une classe concrète qui implémente toutes les méthodes abstraites déclarées dans la classe abstraite. Une méthode abstraite est une méthode qui n’a pas de corps (pas de code entre les accolades) et qui doit être définie dans une classe fille qui hérite de la classe abstraite.
abstract class Shape {
  abstract public function area(); // déclaration de la méthode abstraite area
}

class Square extends Shape {
  public $side;

  public function __construct($side) {
    $this->side = $side;
  }

  public function area() { // implémentation de la méthode abstraite area
    return $this->side * $this->side;
  }
}

$square = new Square(5);
echo $square->area(); // affiche 25

Dans cet exemple, la classe Shape est une classe abstraite qui déclare la méthode abstraite area. La classe Square hérite de la classe Shape et implémente la méthode area en fournissant un corps de code. Vous pouvez alors créer une instance de la classe Square et appeler la méthode area sur cet objet.

Soyez le premier à commenter

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.




Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.