🏗️ Classes Abstraites, Interfaces et Traits en PHP : Le Guide Ultime
Découvrez les différences fondamentales entre ces trois concepts clés de la POO en PHP. Apprenez à choisir la bonne approche pour chaque situation avec des exemples concrets et un tableau comparatif détaillé.
🎯 Objectif
Comprendre les spécificités, avantages et cas d'utilisation des classes abstraites, interfaces et traits en PHP. Savoir choisir le bon outil pour résoudre chaque problème de conception.
1️⃣ Classes Abstraites
Qu'est-ce qu'une classe abstraite ?
Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert de modèle pour d'autres classes. Elle peut contenir à la fois des méthodes implémentées (concrètes) et des méthodes abstraites (sans implémentation).
Pourquoi les classes abstraites existent ?
Les classes abstraites permettent de :
- Forcer un contrat : Obliger les classes enfants à implémenter certaines méthodes
- Partager du code : Fournir une implémentation commune à plusieurs classes
- Créer une hiérarchie logique : Organiser les classes en familles
- Éviter la duplication : Centraliser le code commun
Exemple concret : Animal/Chien/Chat
// ✅ CLASSE ABSTRAITE ANIMAL
<?php
abstract class Animal {
protected $nom;
protected $age;
// Constructeur commun à tous les animaux
public function __construct($nom, $age) {
$this->nom = $nom;
$this->age = $age;
}
// Méthode concrète (implémentée)
public function dormir() {
echo "$this->nom dort... ";
}
// Méthode abstraite (doit être implémentée par les enfants)
abstract public function parler();
// Méthode abstraite avec paramètre
abstract public function manger($nourriture);
}
// CLASSE CONCRÈTE CHIEN
class Chien extends Animal {
// Implémentation obligatoire de la méthode abstraite
public function parler() {
echo "$this->nom dit : Wouf Wouf !";
}
public function manger($nourriture) {
if ($nourriture === 'croquettes') {
echo "$this->nom mange ses croquettes avec joie !";
} else {
echo "$this->name renifle $nourriture avec méfiance.";
}
}
// Méthode spécifique à Chien
public function remuerQueue() {
echo "$this->name remue la queue !";
}
}
// CLASSE CONCRÈTE CHAT
class Chat extends Animal {
public function parler() {
echo "$this->nom dit : Miaou !";
}
public function manger($nourriture) {
if ($nourriture === 'poisson') {
echo "$this->nom dévore le poisson !";
} else {
echo "$this->nom regarde $nourriture avec dédain.";
}
}
// Méthode spécifique à Chat
public function ronronner() {
echo "Rrrrrr Rrrrrr";
}
}
// UTILISATION
$rex = new Chien("Rex", 3);
$felix = new Chat("Félix", 2);
$rex->parler(); // Rex dit : Wouf Wouf !
$rex->dormir(); // Rex dort... Zzz
$rex->manger('croquettes');
$felix->parler(); // Félix dit : Miaou !
$felix->ronronner();
?>
<?php
abstract class Animal {
protected $nom;
protected $age;
// Constructeur commun à tous les animaux
public function __construct($nom, $age) {
$this->nom = $nom;
$this->age = $age;
}
// Méthode concrète (implémentée)
public function dormir() {
echo "$this->nom dort... ";
}
// Méthode abstraite (doit être implémentée par les enfants)
abstract public function parler();
// Méthode abstraite avec paramètre
abstract public function manger($nourriture);
}
// CLASSE CONCRÈTE CHIEN
class Chien extends Animal {
// Implémentation obligatoire de la méthode abstraite
public function parler() {
echo "$this->nom dit : Wouf Wouf !";
}
public function manger($nourriture) {
if ($nourriture === 'croquettes') {
echo "$this->nom mange ses croquettes avec joie !";
} else {
echo "$this->name renifle $nourriture avec méfiance.";
}
}
// Méthode spécifique à Chien
public function remuerQueue() {
echo "$this->name remue la queue !";
}
}
// CLASSE CONCRÈTE CHAT
class Chat extends Animal {
public function parler() {
echo "$this->nom dit : Miaou !";
}
public function manger($nourriture) {
if ($nourriture === 'poisson') {
echo "$this->nom dévore le poisson !";
} else {
echo "$this->nom regarde $nourriture avec dédain.";
}
}
// Méthode spécifique à Chat
public function ronronner() {
echo "Rrrrrr Rrrrrr";
}
}
// UTILISATION
$rex = new Chien("Rex", 3);
$felix = new Chat("Félix", 2);
$rex->parler(); // Rex dit : Wouf Wouf !
$rex->dormir(); // Rex dort... Zzz
$rex->manger('croquettes');
$felix->parler(); // Félix dit : Miaou !
$felix->ronronner();
?>
💡 Points clés des classes abstraites :
- Peuvent contenir des méthodes abstraites (sans corps) et concrètes (avec implémentation)
- Ne peuvent pas être instanciées directement avec
new - Les classes enfants doivent implémenter toutes les méthodes abstraites
- Supportent les propriétés avec valeurs par défaut
- Peuvent avoir un constructeur
- Une classe ne peut étendre qu'une seule classe abstraite
Quand utiliser une classe abstraite ?
- Quand plusieurs classes partagent une logique commune : Code commun à factoriser
- Quand vous voulez forcer un contrat mais aussi fournir une implémentation partielle
- Pour créer une hiérarchie "est-un" : Un Chien "est un" Animal
- Quand vous avez besoin d'un état (propriétés) partagé entre classes enfants
- Pour les familles d'objets étroitement liés avec comportements similaires
2️⃣ Interfaces
Qu'est-ce qu'une interface ?
Une interface est un contrat qui définit uniquement des méthodes (sans implémentation). Une classe qui implémente une interface doit fournir l'implémentation de toutes ses méthodes.
Différence fondamentale avec les classes abstraites
📊 Comparaison rapide :
- Classe abstraite : Peut avoir des méthodes concrètes ET abstraites + propriétés
- Interface : Uniquement des méthodes abstraites (avant PHP 8.0) + pas de propriétés
- Classe abstraite : Relation "est-un" (héritage)
- Interface : Relation "peut-faire" (capacité)
Avantage principal : L'héritage multiple
Contrairement aux classes (abstraites ou non), une classe peut implémenter plusieurs interfaces !
// ✅ INTERFACES ET HÉRITAGE MULTIPLE
<?php
// Interface pour les objets qui peuvent voler
interface Volant {
public function decoller();
public function atterrir();
public function voler();
}
// Interface pour les objets qui peuvent nager
interface Nageant {
public function plonger();
public function nager();
}
// Interface pour les objets qui peuvent courir
interface Courant {
public function courir();
}
// Classe Oiseau - peut voler ET courir
class Oiseau implements Volant, Courant {
protected $nom;
public function __construct($nom) {
$this->nom = $nom;
}
public function decoller() {
echo "$this->nom décolle en battant des ailes !";
}
public function atterrir() {
echo "$this->nom atterrit sur une branche.";
}
public function voler() {
echo "$this->nom plane dans les airs.";
}
public function courir() {
echo "$this->nom court sur le sol.";
}
}
// Classe Canard - peut voler, nager ET courir !
class Canard implements Volant, Nageant, Courant {
protected $nom;
public function __construct($nom) {
$this->nom = $nom;
}
// Implémentation de Volant
public function decoller() {
echo "$this->nom décolle péniblement de l'eau.";
}
public function atterrir() {
echo "$this->nom atterrit sur l'eau en glissant.";
}
public function voler() {
echo "$this->nom vole en formation.";
}
// Implémentation de Nageant
public function plonger() {
echo "$this->nom plonge pour chercher de la nourriture.";
}
public function nager() {
echo "$this->nom nage paisiblement.";
}
// Implémentation de Courant
public function courir() {
echo "$this->name court en se dandinant.";
}
}
// UTILISATION
$aigle = new Oiseau("Aigle royal");
$donald = new Canard("Donald");
echo "=== AIGLE ===<br>";
$aigle->decoller();
$aigle->voler();
$aigle->courir();
echo "<br>=== CANARD ===<br>";
$donald->nager();
$donald->plonger();
$donald->decoller();
$donald->courir();
?>
<?php
// Interface pour les objets qui peuvent voler
interface Volant {
public function decoller();
public function atterrir();
public function voler();
}
// Interface pour les objets qui peuvent nager
interface Nageant {
public function plonger();
public function nager();
}
// Interface pour les objets qui peuvent courir
interface Courant {
public function courir();
}
// Classe Oiseau - peut voler ET courir
class Oiseau implements Volant, Courant {
protected $nom;
public function __construct($nom) {
$this->nom = $nom;
}
public function decoller() {
echo "$this->nom décolle en battant des ailes !";
}
public function atterrir() {
echo "$this->nom atterrit sur une branche.";
}
public function voler() {
echo "$this->nom plane dans les airs.";
}
public function courir() {
echo "$this->nom court sur le sol.";
}
}
// Classe Canard - peut voler, nager ET courir !
class Canard implements Volant, Nageant, Courant {
protected $nom;
public function __construct($nom) {
$this->nom = $nom;
}
// Implémentation de Volant
public function decoller() {
echo "$this->nom décolle péniblement de l'eau.";
}
public function atterrir() {
echo "$this->nom atterrit sur l'eau en glissant.";
}
public function voler() {
echo "$this->nom vole en formation.";
}
// Implémentation de Nageant
public function plonger() {
echo "$this->nom plonge pour chercher de la nourriture.";
}
public function nager() {
echo "$this->nom nage paisiblement.";
}
// Implémentation de Courant
public function courir() {
echo "$this->name court en se dandinant.";
}
}
// UTILISATION
$aigle = new Oiseau("Aigle royal");
$donald = new Canard("Donald");
echo "=== AIGLE ===<br>";
$aigle->decoller();
$aigle->voler();
$aigle->courir();
echo "<br>=== CANARD ===<br>";
$donald->nager();
$donald->plonger();
$donald->decoller();
$donald->courir();
?>
Exemple concret : Système de paiement
// ✅ INTERFACE POUR SYSTÈME DE PAIEMENT
<?php
interface MoyenPaiement {
public function authentifier();
public function payer($montant);
public function annulerPaiement($transactionId);
}
// Classe concrète Carte Bancaire
class CarteBancaire implements MoyenPaiement {
private $numeroCarte;
private $titulaire;
public function __construct($numeroCarte, $titulaire) {
$this->numeroCarte = $numeroCarte;
$this->titulaire = $titulaire;
}
public function authentifier() {
// Logique d'authentification par carte
echo "Authentification carte bancaire pour $this->titulaire";
return true;
}
public function payer($montant) {
if (!$this->authentifier()) {
throw new Exception("Authentification échouée");
}
// Logique de paiement par carte
$transactionId = uniqid('CB_');
echo "Paiement de $montant€ par carte. Transaction : $transactionId";
return $transactionId;
}
public function annulerPaiement($transactionId) {
echo "Annulation de la transaction $transactionId sur carte bancaire";
return true;
}
}
// Classe concrète PayPal
class PayPal implements MoyenPaiement {
private $email;
public function __construct($email) {
$this->email = $email;
}
public function authentifier() {
// Logique d'authentification PayPal
echo "Connexion à PayPal avec $this->email";
return true;
}
public function payer($montant) {
if (!$this->authentifier()) {
throw new Exception("Connexion PayPal échouée");
}
$transactionId = uniqid('PP_');
echo "Paiement de $montant€ via PayPal. Transaction : $transactionId";
return $transactionId;
}
public function annulerPaiement($transactionId) {
echo "Annulation de la transaction $transactionId sur PayPal";
return true;
}
}
// UTILISATION POLYMORPHE
function traiterPaiement(MoyenPaiement $moyen, $montant) {
try {
return $moyen->payer($montant);
} catch (Exception $e) {
echo "Erreur de paiement : " . $e->getMessage();
return false;
}
}
// On peut utiliser n'importe quel moyen de paiement !
$carte = new CarteBancaire("1234-5678-9012-3456", "Alice Dupont");
$paypal = new PayPal("alice@example.com");
echo "=== Paiement par carte ===<br>";
traiterPaiement($carte, 99.99);
echo "<br>=== Paiement par PayPal ===<br>";
traiterPaiement($paypal, 49.99);
?>
<?php
interface MoyenPaiement {
public function authentifier();
public function payer($montant);
public function annulerPaiement($transactionId);
}
// Classe concrète Carte Bancaire
class CarteBancaire implements MoyenPaiement {
private $numeroCarte;
private $titulaire;
public function __construct($numeroCarte, $titulaire) {
$this->numeroCarte = $numeroCarte;
$this->titulaire = $titulaire;
}
public function authentifier() {
// Logique d'authentification par carte
echo "Authentification carte bancaire pour $this->titulaire";
return true;
}
public function payer($montant) {
if (!$this->authentifier()) {
throw new Exception("Authentification échouée");
}
// Logique de paiement par carte
$transactionId = uniqid('CB_');
echo "Paiement de $montant€ par carte. Transaction : $transactionId";
return $transactionId;
}
public function annulerPaiement($transactionId) {
echo "Annulation de la transaction $transactionId sur carte bancaire";
return true;
}
}
// Classe concrète PayPal
class PayPal implements MoyenPaiement {
private $email;
public function __construct($email) {
$this->email = $email;
}
public function authentifier() {
// Logique d'authentification PayPal
echo "Connexion à PayPal avec $this->email";
return true;
}
public function payer($montant) {
if (!$this->authentifier()) {
throw new Exception("Connexion PayPal échouée");
}
$transactionId = uniqid('PP_');
echo "Paiement de $montant€ via PayPal. Transaction : $transactionId";
return $transactionId;
}
public function annulerPaiement($transactionId) {
echo "Annulation de la transaction $transactionId sur PayPal";
return true;
}
}
// UTILISATION POLYMORPHE
function traiterPaiement(MoyenPaiement $moyen, $montant) {
try {
return $moyen->payer($montant);
} catch (Exception $e) {
echo "Erreur de paiement : " . $e->getMessage();
return false;
}
}
// On peut utiliser n'importe quel moyen de paiement !
$carte = new CarteBancaire("1234-5678-9012-3456", "Alice Dupont");
$paypal = new PayPal("alice@example.com");
echo "=== Paiement par carte ===<br>";
traiterPaiement($carte, 99.99);
echo "<br>=== Paiement par PayPal ===<br>";
traiterPaiement($paypal, 49.99);
?>
💡 Points clés des interfaces :
- 100% abstraites (avant PHP 8.0, maintenant peuvent avoir des méthodes concrètes)
- Pas de propriétés (seulement des constantes)
- Pas de constructeur
- Héritage multiple : une classe peut implémenter plusieurs interfaces
- Définissent un contrat que les classes doivent respecter
- Idéales pour le polymorphisme et la flexibilité
3️⃣ Traits
Qu'est-ce qu'un trait ?
Un trait est un mécanisme de réutilisation de code dans les langages à héritage simple comme PHP. Il permet d'injecter des méthodes dans une classe, sans utiliser l'héritage.
Use cases principaux
// ✅ TRAIT POUR LE LOGGING
<?php
trait LoggerTrait {
private $logs = [];
public function log($message, $level = 'INFO') {
$timestamp = date('Y-m-d H:i:s');
$logEntry = "$timestamp [$level] $message";
$this->logs[] = $logEntry;
echo "LOG: $logEntry<br>";
}
public function getLogs() {
return $this->logs;
}
public function clearLogs() {
$this->logs = [];
}
}
// TRAIT POUR LE CACHE
trait CacheTrait {
private $cache = [];
private $defaultTtl = 3600; // 1 heure
public function cacheSet($key, $value, $ttl = null) {
if ($ttl === null) {
$ttl = $this->defaultTtl;
}
$expires = time() + $ttl;
$this->cache[$key] = [
'value' => $value,
'expires' => $expires
];
$this->log("Cache set for key: $key (TTL: $ttls)");
}
public function cacheGet($key) {
if (!isset($this->cache[$key])) {
$this->log("Cache miss for key: $key", 'WARNING');
return null;
}
$item = $this->cache[$key];
if (time() > $item['expires']) {
unset($this->cache[$key]);
$this->log("Cache expired for key: $key", 'WARNING');
return null;
}
$this->log("Cache hit for key: $key");
return $item['value'];
}
public function cacheClear() {
$count = count($this->cache);
$this->cache = [];
$this->log("Cache cleared ($count items removed)");
}
}
// TRAIT POUR LA SÉRIALISATION JSON
trait JsonSerializableTrait {
public function toJson() {
return json_encode($this, JSON_PRETTY_PRINT);
}
public function fromJson($json) {
$data = json_decode($json, true);
foreach ($data as $key => $value) {
if (property_exists($this, $key)) {
$this->{$key} = $value;
}
}
}
}
// CLASSE UTILISANT PLUSIEURS TRAITS
class ApiClient {
use LoggerTrait, CacheTrait, JsonSerializableTrait;
private $apiKey;
private $baseUrl;
public function __construct($apiKey, $baseUrl) {
$this->apiKey = $apiKey;
$this->baseUrl = $baseUrl;
$this->log("ApiClient initialized for: $baseUrl");
}
public function fetchData($endpoint) {
$cacheKey = "api_$endpoint";
// Vérifier le cache d'abord
$cached = $this->cacheGet($cacheKey);
if ($cached !== null) {
return $cached;
}
// Appel API réel
$this->log("Fetching from API: $endpoint");
// Simulation d'appel API
$data = ['result' => "Data from $endpoint", 'timestamp' => time()];
// Mettre en cache
$this->cacheSet($cacheKey, $data, 300); // 5 minutes
return $data;
}
}
// AUTRE CLASSE UTILISANT LES MÊMES TRAITS
class UserRepository {
use LoggerTrait, JsonSerializableTrait;
private $users = [];
public function addUser($user) {
$this->users[] = $user;
$this->log("User added: " . json_encode($user));
}
}
// UTILISATION
$api = new ApiClient("abc123", "https://api.example.com");
$data = $api->fetchData("/users");
echo "Data: " . json_encode($data) . "<br>";
// Deuxième appel - devrait venir du cache
$data2 = $api->fetchData("/users");
echo "<br>Logs:<br>";
foreach ($api->getLogs() as $log) {
echo $log . "<br>";
}
?>
<?php
trait LoggerTrait {
private $logs = [];
public function log($message, $level = 'INFO') {
$timestamp = date('Y-m-d H:i:s');
$logEntry = "$timestamp [$level] $message";
$this->logs[] = $logEntry;
echo "LOG: $logEntry<br>";
}
public function getLogs() {
return $this->logs;
}
public function clearLogs() {
$this->logs = [];
}
}
// TRAIT POUR LE CACHE
trait CacheTrait {
private $cache = [];
private $defaultTtl = 3600; // 1 heure
public function cacheSet($key, $value, $ttl = null) {
if ($ttl === null) {
$ttl = $this->defaultTtl;
}
$expires = time() + $ttl;
$this->cache[$key] = [
'value' => $value,
'expires' => $expires
];
$this->log("Cache set for key: $key (TTL: $ttls)");
}
public function cacheGet($key) {
if (!isset($this->cache[$key])) {
$this->log("Cache miss for key: $key", 'WARNING');
return null;
}
$item = $this->cache[$key];
if (time() > $item['expires']) {
unset($this->cache[$key]);
$this->log("Cache expired for key: $key", 'WARNING');
return null;
}
$this->log("Cache hit for key: $key");
return $item['value'];
}
public function cacheClear() {
$count = count($this->cache);
$this->cache = [];
$this->log("Cache cleared ($count items removed)");
}
}
// TRAIT POUR LA SÉRIALISATION JSON
trait JsonSerializableTrait {
public function toJson() {
return json_encode($this, JSON_PRETTY_PRINT);
}
public function fromJson($json) {
$data = json_decode($json, true);
foreach ($data as $key => $value) {
if (property_exists($this, $key)) {
$this->{$key} = $value;
}
}
}
}
// CLASSE UTILISANT PLUSIEURS TRAITS
class ApiClient {
use LoggerTrait, CacheTrait, JsonSerializableTrait;
private $apiKey;
private $baseUrl;
public function __construct($apiKey, $baseUrl) {
$this->apiKey = $apiKey;
$this->baseUrl = $baseUrl;
$this->log("ApiClient initialized for: $baseUrl");
}
public function fetchData($endpoint) {
$cacheKey = "api_$endpoint";
// Vérifier le cache d'abord
$cached = $this->cacheGet($cacheKey);
if ($cached !== null) {
return $cached;
}
// Appel API réel
$this->log("Fetching from API: $endpoint");
// Simulation d'appel API
$data = ['result' => "Data from $endpoint", 'timestamp' => time()];
// Mettre en cache
$this->cacheSet($cacheKey, $data, 300); // 5 minutes
return $data;
}
}
// AUTRE CLASSE UTILISANT LES MÊMES TRAITS
class UserRepository {
use LoggerTrait, JsonSerializableTrait;
private $users = [];
public function addUser($user) {
$this->users[] = $user;
$this->log("User added: " . json_encode($user));
}
}
// UTILISATION
$api = new ApiClient("abc123", "https://api.example.com");
$data = $api->fetchData("/users");
echo "Data: " . json_encode($data) . "<br>";
// Deuxième appel - devrait venir du cache
$data2 = $api->fetchData("/users");
echo "<br>Logs:<br>";
foreach ($api->getLogs() as $log) {
echo $log . "<br>";
}
?>
💡 Points clés des traits :
- Réutilisation horizontale de code (vs héritage vertical)
- Pas de relation "est-un" comme l'héritage
- Peuvent contenir des méthodes concrètes ET abstraites
- Peuvent avoir des propriétés
- Résolvent le problème de l'héritage multiple en PHP
- Idéaux pour les fonctionnalités transversales (logging, cache, etc.)
Autres use cases courants pour les traits :
- Singleton pattern : Garantir une seule instance
- SoftDeletes : Suppression logique (comme dans Laravel)
- Timestamps : Gestion automatique des dates created_at/updated_at
- Slug generation : Création automatique de slugs
- Authorization : Gestion des permissions
- Notifications : Système d'envoi de notifications
4️⃣ Comparaison : Abstraite vs Interface vs Trait
Tableau récapitulatif
| Caractéristique | Classe Abstraite | Interface | Trait |
|---|---|---|---|
| Instanciation | ❌ Non | ❌ Non | ❌ Non |
| Méthodes concrètes | ✅ Oui | ✅ Depuis PHP 8.0 | ✅ Oui |
| Méthodes abstraites | ✅ Oui | ✅ Oui | ✅ Oui |
| Propriétés | ✅ Oui | ❌ Non (constantes seulement) | ✅ Oui |
| Constructeur | ✅ Oui | ❌ Non | ✅ Oui |
| Héritage multiple | ❌ Non (une seule) | ✅ Oui (plusieurs) | ✅ Oui (plusieurs) |
| Visibilité | public/protected/private | public seulement | public/protected/private |
| Relation | "EST-UN" (héritage) | "PEUT-FAIRE" (contrat) | "A" (composition) |
| Mot-clé | extends |
implements |
use |
| Cas typique | Animal → Chien/Chat | MoyenPaiement → Carte/PayPal | LoggerTrait, CacheTrait |
Quand utiliser quoi ?
✅ Utilisez une CLASSE ABSTRAITE quand :
- Plusieurs classes partagent une logique commune importante
- Vous avez besoin de propriétés avec valeurs par défaut
- La relation entre les classes est "est-un" (héritage fort)
- Vous voulez forcer un contrat ET fournir une implémentation
- Les classes enfants sont étroitement liées conceptuellement
- Exemple :
Vehicule→Voiture,Moto
✅ Utilisez une INTERFACE quand :
- Vous définissez un contrat que différentes classes doivent respecter
- Vous avez besoin d'héritage multiple
- La relation est "peut-faire" (capacité) plutôt que "est-un"
- Vous voulez permettre à des classes non reliées d'avoir le même comportement
- Pour le polymorphisme avec des types non reliés
- Exemple :
Exportable,Authentifiable,Notifiable
✅ Utilisez un TRAIT quand :
- Vous avez du code à réutiliser horizontalement dans plusieurs classes
- Vous voulez éviter la duplication de code sans créer de hiérarchie
- La fonctionnalité est transversale et peut être utile à différentes classes
- Vous voulez composer des classes avec différentes fonctionnalités
- Pour les fonctionnalités optionnelles qu'une classe peut "avoir"
- Exemple :
Loggable,Cacheable,Timestampable
Exemple combinant les trois concepts
// ✅ EXEMPLE COMPLET COMBINANT LES 3 CONCEPTS
<?php
// INTERFACE - Contrat pour les éléments avec prix
interface Prixable {
public function getPrix();
public function appliquerRemise($pourcentage);
}
// TRAIT - Fonctionnalité de logging réutilisable
trait Loggeable {
protected $logs = [];
public function log($message) {
$this->logs[] = date('Y-m-d H:i:s') . " - $message";
}
public function getLogs() {
return $this->logs;
}
}
// CLASSE ABSTRAITE - Base commune pour les produits
abstract class Produit implements Prixable {
use Loggeable; // Utilisation du trait
protected $nom;
protected $prix;
protected $description;
public function __construct($nom, $prix, $description = '') {
$this->nom = $nom;
$this->prix = $prix;
$this->description = $description;
$this->log("Produit créé : $nom");
}
// Méthode concrète commune
public function getNom() {
return $this->nom;
}
// Implémentation de l'interface Prixable
public function getPrix() {
return $this->prix;
}
public function appliquerRemise($pourcentage) {
if ($pourcentage < 0 || $pourcentage > 100) {
throw new InvalidArgumentException("Pourcentage invalide");
}
$reduction = $this->prix * ($pourcentage / 100);
$this->prix -= $reduction;
$this->log("Remise de $pourcentage% appliquée. Nouveau prix : $this->prix€");
return $this->prix;
}
// Méthode abstraite - doit être implémentée par les enfants
abstract public function getCaracteristiques();
}
// CLASSE CONCRÈTE - Livre
class Livre extends Produit {
private $auteur;
private $isbn;
public function __construct($nom, $prix, $auteur, $isbn) {
parent::__construct($nom, $prix, "Livre de $auteur");
$this->auteur = $auteur;
$this->isbn = $isbn;
}
// Implémentation de la méthode abstraite
public function getCaracteristiques() {
return [
'type' => 'Livre',
'auteur' => $this->auteur,
'isbn' => $this->isbn
];
}
}
// CLASSE CONCRÈTE - Electronique
class ProduitElectronique extends Produit {
private $marque;
private $modele;
private $garantie; // en mois
public function __construct($nom, $prix, $marque, $modele, $garantie = 24) {
parent::__construct($nom, $prix, "Produit électronique $marque $modele");
$this->marque = $marque;
$this->modele = $modele;
$this->garantie = $garantie;
}
public function getCaracteristiques() {
return [
'type' => 'Électronique',
'marque' => $this->marque,
'modele' => $this->modele,
'garantie' => $this->garantie . ' mois'
];
}
}
// UTILISATION
$livre = new Livre("PHP Avancé", 29.99, "John Doe", "978-1234567890");
$smartphone = new ProduitElectronique("Smartphone Pro", 799.99, "TechBrand", "X100", 36);
echo "=== LIVRE ===<br>";
echo "Nom: " . $livre->getNom() . "<br>";
echo "Prix: " . $livre->getPrix() . "€<br>";
$livre->appliquerRemise(10);
echo "Prix après remise: " . $livre->getPrix() . "€<br>";
echo "=== SMARTPHONE ===<br>";
$smartphone->appliquerRemise(15);
// Polymorphisme avec l'interface
$produits = [$livre, $smartphone];
$total = 0;
foreach ($produits as $produit) {
$total += $produit->getPrix();
}
echo "Total panier: $total€<br>";
echo "=== LOGS DU LIVRE ===<br>";
foreach ($livre->getLogs() as $log) {
echo $log . "<br>";
}
?>
<?php
// INTERFACE - Contrat pour les éléments avec prix
interface Prixable {
public function getPrix();
public function appliquerRemise($pourcentage);
}
// TRAIT - Fonctionnalité de logging réutilisable
trait Loggeable {
protected $logs = [];
public function log($message) {
$this->logs[] = date('Y-m-d H:i:s') . " - $message";
}
public function getLogs() {
return $this->logs;
}
}
// CLASSE ABSTRAITE - Base commune pour les produits
abstract class Produit implements Prixable {
use Loggeable; // Utilisation du trait
protected $nom;
protected $prix;
protected $description;
public function __construct($nom, $prix, $description = '') {
$this->nom = $nom;
$this->prix = $prix;
$this->description = $description;
$this->log("Produit créé : $nom");
}
// Méthode concrète commune
public function getNom() {
return $this->nom;
}
// Implémentation de l'interface Prixable
public function getPrix() {
return $this->prix;
}
public function appliquerRemise($pourcentage) {
if ($pourcentage < 0 || $pourcentage > 100) {
throw new InvalidArgumentException("Pourcentage invalide");
}
$reduction = $this->prix * ($pourcentage / 100);
$this->prix -= $reduction;
$this->log("Remise de $pourcentage% appliquée. Nouveau prix : $this->prix€");
return $this->prix;
}
// Méthode abstraite - doit être implémentée par les enfants
abstract public function getCaracteristiques();
}
// CLASSE CONCRÈTE - Livre
class Livre extends Produit {
private $auteur;
private $isbn;
public function __construct($nom, $prix, $auteur, $isbn) {
parent::__construct($nom, $prix, "Livre de $auteur");
$this->auteur = $auteur;
$this->isbn = $isbn;
}
// Implémentation de la méthode abstraite
public function getCaracteristiques() {
return [
'type' => 'Livre',
'auteur' => $this->auteur,
'isbn' => $this->isbn
];
}
}
// CLASSE CONCRÈTE - Electronique
class ProduitElectronique extends Produit {
private $marque;
private $modele;
private $garantie; // en mois
public function __construct($nom, $prix, $marque, $modele, $garantie = 24) {
parent::__construct($nom, $prix, "Produit électronique $marque $modele");
$this->marque = $marque;
$this->modele = $modele;
$this->garantie = $garantie;
}
public function getCaracteristiques() {
return [
'type' => 'Électronique',
'marque' => $this->marque,
'modele' => $this->modele,
'garantie' => $this->garantie . ' mois'
];
}
}
// UTILISATION
$livre = new Livre("PHP Avancé", 29.99, "John Doe", "978-1234567890");
$smartphone = new ProduitElectronique("Smartphone Pro", 799.99, "TechBrand", "X100", 36);
echo "=== LIVRE ===<br>";
echo "Nom: " . $livre->getNom() . "<br>";
echo "Prix: " . $livre->getPrix() . "€<br>";
$livre->appliquerRemise(10);
echo "Prix après remise: " . $livre->getPrix() . "€<br>";
echo "=== SMARTPHONE ===<br>";
$smartphone->appliquerRemise(15);
// Polymorphisme avec l'interface
$produits = [$livre, $smartphone];
$total = 0;
foreach ($produits as $produit) {
$total += $produit->getPrix();
}
echo "Total panier: $total€<br>";
echo "=== LOGS DU LIVRE ===<br>";
foreach ($livre->getLogs() as $log) {
echo $log . "<br>";
}
?>
5️⃣ Conclusion
✅ Récapitulatif des concepts clés :
- Classe abstraite : Pour créer une hiérarchie "est-un" avec code commun
- Interface : Pour définir des contrats et permettre l'héritage multiple
- Trait : Pour réutiliser du code horizontalement sans héritage
Guide de décision rapide
- Plusieurs classes étroitement liées avec logique commune ? → Classe abstraite
- Besoin de définir un contrat pour des classes non reliées ? → Interface
- Code à réutiliser dans différentes hiérarchies de classes ? → Trait
- Besoin d'héritage multiple ? → Interface (ou Traits)
- État (propriétés) à partager ? → Classe abstraite ou Trait
- Fonctionnalités optionnelles/composables ? → Traits
🚀 Prochain article
Dans le prochain article, découvrez les Design Patterns en PHP !
👉 "Design Patterns en PHP : Singleton, Factory, Observer et plus"
Apprenez à résoudre des problèmes récurrents de conception avec les patterns les plus utilisés en PHP. Des exemples concrets pour structurer vos applications comme un pro !
💻 Héberge ton site avant que le web s'écroule !
Si tu veux pas que tes projets PHP/MySQL dorment dans ton PC comme un brocoli oublié, utilise IONOS.
Mon lien de parrainage est là pour t'aider, et moi ça m'aide à survivre (ou juste à acheter du café).
Questions Fréquentes
Quelle est la différence principale entre une classe abstraite et une interface ?
Une classe abstraite peut contenir à la fois des méthodes implémentées et abstraites, ainsi que des propriétés. Une interface (avant PHP 8.0) ne contient que des méthodes abstraites et des constantes. La relation est différente : "est-un" pour l'abstraite, "peut-faire" pour l'interface.
Quand utiliser un trait plutôt qu'une classe abstraite ?
Utilisez un trait quand vous voulez réutiliser du code dans des classes qui n'ont pas de relation parent-enfant. Utilisez une classe abstraite quand les classes partagent une relation "est-un" et ont une logique commune importante.
Est-ce qu'une classe peut à la fois étendre une classe abstraite et implémenter une interface ?
Oui ! Une classe peut étendre une seule classe (abstraite ou non) ET implémenter plusieurs interfaces. C'est très courant en PHP.
Les traits peuvent-ils remplacer complètement les interfaces ?
Non. Les traits et les interfaces servent des buts différents. Les interfaces définissent un contrat (quoi faire), tandis que les traits fournissent une implémentation (comment le faire). On les utilise souvent ensemble.
Peut-on instancier un trait directement ?
Non. Un trait n'est pas une classe et ne peut pas être instancié. Il doit être utilisé (use) à l'intérieur d'une classe.
