Petit résumé
Petit résumé de la POO en PHP
1. Un objet
Définition :
Un objet est une instance (une réalisation concrète) d’une classe. Il représente une entité qui possède un état (des propriétés) et un comportement (des méthodes).
Explication :
Dans la POO, l’objet est l’élément central. La classe est le « plan » (le modèle), l’objet est la « maison construite » à partir de ce plan.
Chaque objet est indépendant et peut interagir avec d’autres objets. En PHP, on accède à ses propriétés et méthodes via l’opérateur ->.
Exemple :
class Voiture {
// Propriétés (état de l'objet)
public $marque;
public $couleur;
// Méthodes (comportement)
public function demarrer() {
echo $this->marque . " démarre !\n";
}
}
// Création d'un objet (instance)
$maVoiture = new Voiture();
$maVoiture->marque = "Peugeot";
$maVoiture->couleur = "Rouge";
$maVoiture->demarrer(); // Affiche : Peugeot démarre !
2. L’héritage (Inheritance)
Définition :
L’héritage est un mécanisme qui permet à une classe enfant (ou dérivée) d’acquérir les propriétés et méthodes d’une classe parente (ou de base), en utilisant le mot-clé extends.
Explication :
L’héritage permet la réutilisation du code et modélise une relation « est-un » (is-a). PHP ne supporte que l’héritage simple (une seule classe parente). La classe enfant peut redéfinir (surcharger) les méthodes de la classe parente.
Exemple :
class Vehicule { // Classe parente
protected $vitesse = 0;
public function accelerer($kmh) {
$this->vitesse += $kmh;
echo "Vitesse : " . $this->vitesse . " km/h\n";
}
}
class Voiture extends Vehicule { // Classe enfant
public $nombrePortes = 5;
public function klaxonner() {
echo "Pouet pouet !\n";
}
}
$maVoiture = new Voiture();
$maVoiture->accelerer(50); // Hérité de Vehicule
$maVoiture->klaxonner(); // Propre à Voiture
3. L’encapsulation
Définition :
L’encapsulation est le principe qui consiste à regrouper les propriétés et les méthodes dans une même classe, tout en contrôlant l’accès à ces données.
Explication :
On utilise les modificateurs de visibilité :
public→ accessible partoutprotected→ accessible dans la classe et les classes enfantsprivate→ accessible uniquement dans la classe
On protège les données avec des getters et setters.
Exemple :
class CompteBancaire {
private $solde = 0; // Encapsulé
public function deposer($montant) {
if ($montant > 0) {
$this->solde += $montant;
}
}
public function getSolde() { // Getter
return $this->solde;
}
}
$compte = new CompteBancaire();
$compte->deposer(1000);
// $compte->solde = -500; → Impossible (private)
echo "Solde : " . $compte->getSolde() . " €\n";
4. Le polymorphisme
Définition :
Le polymorphisme (« plusieurs formes ») permet à des objets de classes différentes d’être manipulés de la même manière via une classe parente commune.
Explication :
Grâce à la redéfinition (surcharge) de méthodes, chaque classe peut avoir son propre comportement tout en partageant une classe parente commune.
La classe parente commune est souvent une classe abstraite ou une interface.
Exemple :
class Animal {
public function faireDuBruit() {
echo "Bruit générique...\n";
}
}
class Chien extends Animal {
public function faireDuBruit() { // Redéfinition
echo "Wouf Wouf !\n";
}
}
class Chat extends Animal {
public function faireDuBruit() { // Redéfinition
echo "Miaou !\n";
}
}
// Polymorphisme
$animaux = [new Chien(), new Chat()];
foreach ($animaux as $animal) {
$animal->faireDuBruit(); // Comportement différent selon l'objet réel
}
5. L’abstraction
Définition :
L’abstraction consiste à masquer les détails d’implémentation complexes pour ne montrer que les fonctionnalités essentielles à l’utilisateur.
Explication :
C’est l’un des quatre piliers de la POO. Elle permet de se concentrer sur « quoi » fait l’objet plutôt que « comment » il le fait. En PHP, elle est concrètement réalisée par les classes abstraites et les interfaces.
Exemple :
(voir l'exemple de classe abstraite ci-dessous)
6. Une classe abstraite
Définition :
Une classe abstraite est une classe déclarée avec le mot-clé abstract qui ne peut pas être instanciée directement et qui peut contenir des méthodes abstraites (sans corps).
Explication :
Elle sert de modèle ou de base pour d’autres classes. Les classes qui en héritent doivent implémenter toutes les méthodes abstraites. Elle permet de forcer une structure commune tout en autorisant du code partagé.
Exemple :
abstract class Vehicule { // Classe abstraite
protected $vitesse;
// Méthode abstraite (doit être implémentée)
abstract public function demarrer();
// Méthode concrète (peut être héritée telle quelle)
public function arreter() {
$this->vitesse = 0;
echo "Véhicule arrêté.\n";
}
}
class Voiture extends Vehicule {
public function demarrer() {
echo "La voiture démarre avec la clé.\n";
}
}
$voiture = new Voiture();
$voiture->demarrer(); // Obligatoire d'implémenter
$voiture->arreter();
7. Une interface
Définition :
Une interface est un contrat qui définit un ensemble de méthodes (sans implémentation) qu’une classe doit obligatoirement implémenter. On utilise le mot-clé implements.
Explication :
- Une classe peut implémenter plusieurs interfaces (contrairement à l’héritage).
- Une interface ne contient généralement pas de propriétés (sauf constantes).
Exemple :
interface Electrifiable {
public function chargerBatterie();
public function getAutonomieWLTP(): int;
}
class VoitureElectrique implements Electrifiable {
public function chargerBatterie() {
echo "Batterie en charge...\n";
}
public function getAutonomieWLTP(): int {
return 400; // km WLTP
}
}
$tesla = new VoitureElectrique();
$tesla->chargerBatterie();
echo "Autonomie : " . $tesla->getAutonomieWLTP() . " km WLTP\n";
Ces concepts sont les piliers de la POO en PHP. Ils sont souvent utilisés ensemble (ex. : une classe abstraite qui implémente une interface, avec héritage et encapsulation).