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éespublicsont 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éesprotectedne 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éesprivatene 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éefinalne 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éeabstractne 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.
Be the first to comment