Semaine 4 - Jour 1 : Introduction à la Programmation Orientée Objet (POO)

La POO permet d'organiser le code en classes et objets pour une meilleure structure, réutilisabilité et maintenance.

1. Qu'est-ce que la POO ?

Programmation Procédurale vs POO

Procédurale (classique)

Code organisé en fonctions et variables globales.

<?php
$nom = "Jean";
$age = 25;

function afficherUtilisateur() {
    global $nom, $age;
    echo "$nom, $age ans";
}
?>

POO (Orientée Objet)

Code organisé en classes et objets.

<?php
class Utilisateur {
    public $nom;
    public $age;

    public function afficher() {
        echo "$this->nom, $this->age ans";
    }
}
?>
Avantages de la POO :
  • Code mieux organisé et réutilisable
  • Données et fonctions regroupées logiquement
  • Facilite la maintenance et l'évolution
  • Standard de l'industrie (frameworks, CMS...)

2. Classes et Objets

Créer une classe

<?php
// Définir une classe (plan / modèle)
class Utilisateur {
    // Propriétés (variables de la classe)
    public $nom;
    public $prenom;
    public $email;

    // Méthodes (fonctions de la classe)
    public function afficherNomComplet() {
        return $this->prenom . " " . $this->nom;
    }

    public function envoyerEmail($message) {
        return "Email envoyé à " . $this->email . ": " . $message;
    }
}
?>

Créer des objets (instances)

<?php
// Créer un objet avec 'new'
$user1 = new Utilisateur();
$user1->nom = "Dupont";
$user1->prenom = "Jean";
$user1->email = "jean.dupont@example.com";

echo $user1->afficherNomComplet(); // Jean Dupont
echo $user1->envoyerEmail("Bonjour !");

// Créer un autre objet indépendant
$user2 = new Utilisateur();
$user2->nom = "Martin";
$user2->prenom = "Marie";
$user2->email = "marie.martin@example.com";

echo $user2->afficherNomComplet(); // Marie Martin
?>

Résultat :

Jean Dupont
Email envoyé à jean.dupont@example.com: Bonjour !
Marie Martin

Vocabulaire POO :

  • Classe : Modèle / Plan (comme un plan de maison)
  • Objet : Instance de la classe (une maison construite selon le plan)
  • Propriété : Variable d'un objet (nom, email...)
  • Méthode : Fonction d'un objet (afficher(), envoyer()...)

3. Le constructeur __construct()

Initialiser un objet automatiquement

<?php
// Classe avec constructeur
class Utilisateur {
    public $nom;
    public $prenom;
    public $email;

    // Constructeur : appelé automatiquement à la création
    public function __construct($nom, $prenom, $email) {
        $this->nom = $nom;
        $this->prenom = $prenom;
        $this->email = $email;

        echo "Nouvel utilisateur créé : $prenom $nom<br>";
    }

    public function afficherInfo() {
        return "$this->prenom $this->nom ($this->email)";
    }
}

// Créer des objets avec le constructeur
$user1 = new Utilisateur("Dupont", "Jean", "jean@example.com");
$user2 = new Utilisateur("Martin", "Marie", "marie@example.com");

echo $user1->afficherInfo();
echo "<br>";
echo $user2->afficherInfo();
?>

Résultat :

Nouvel utilisateur créé : Jean Dupont
Nouvel utilisateur créé : Marie Martin
Jean Dupont (jean@example.com)
Marie Martin (marie@example.com)

Constructeur avec valeurs par défaut

<?php
class Utilisateur {
    public $nom;
    public $prenom;
    public $role;

    // Paramètres avec valeurs par défaut
    public function __construct($nom, $prenom, $role = "utilisateur") {
        $this->nom = $nom;
        $this->prenom = $prenom;
        $this->role = $role;
    }
}

$user1 = new Utilisateur("Dupont", "Jean"); // role = "utilisateur"
$user2 = new Utilisateur("Admin", "Super", "admin"); // role = "admin"

echo $user1->role; // utilisateur
echo $user2->role; // admin
?>

4. $this : Référence à l'objet courant

Comprendre $this

<?php
class Compteur {
    public $valeur = 0;

    public function incrementer() {
        // $this fait référence à l'objet en cours
        $this->valeur++;
        return $this->valeur;
    }

    public function decrementer() {
        $this->valeur--;
        return $this->valeur;
    }

    public function afficher() { echo "Valeur actuelle : $this->valeur<br>";
    }
}

// Créer deux compteurs indépendants
$compteur1 = new Compteur();
$compteur2 = new Compteur();

$compteur1->incrementer();
$compteur1->incrementer();
$compteur1->incrementer();

$compteur2->incrementer();

$compteur1->afficher(); // Valeur actuelle : 3
$compteur2->afficher(); // Valeur actuelle : 1
?>
$this permet d'accéder aux propriétés et méthodes de l'objet depuis l'intérieur de la classe. C'est comme dire "moi-même".

5. Exemple complet : Classe Utilisateur

Application pratique

<?php
// Utilisateur.php
class Utilisateur {
    // Propriétés
    public $id;
    public $nom;
    public $prenom;
    public $email;
    public $dateInscription;

    // Constructeur
    public function __construct($id, $nom, $prenom, $email) {
        $this->id = $id;
        $this->nom = $nom;
        $this->prenom = $prenom;
        $this->email = $email;
        $this->dateInscription = date("Y-m-d H:i:s");
    }

    // Méthode pour afficher le nom complet
    public function getNomComplet() {
        return $this->prenom . " " . $this->nom;
    }

    // Méthode pour obtenir les initiales
    public function getInitiales() {
        return strtoupper($this->prenom[0] . $this->nom[0]);
    }

    // Méthode pour envoyer un email
    public function envoyerEmail($sujet, $message) {
        return "Email envoyé à " . $this->email . "\n" . "Sujet : $sujet\n" . "Message : $message";
    }

    // Méthode pour afficher toutes les infos
    public function afficherProfil() {
        echo "<div class='profil'>";
        echo " <h3>$this->prenom $this->nom</h3>";
        echo " <p>Email : " . htmlspecialchars($this->email) . "</p>";
        echo " <p>Initiales : " . $this->getInitiales() . "</p>";
        echo " <p>Inscrit le : " . $this->dateInscription . "</p>";
        echo "</div>";
    }
}

// Utilisation
$user1 = new Utilisateur(1, "Dupont", "Jean", "jean.dupont@example.com");
$user2 = new Utilisateur(2, "Martin", "Marie", "marie.martin@example.com");

echo $user1->getNomComplet() . "<br>";
echo $user1->getInitiales() . "<br>";

$user1->afficherProfil();
$user2->afficherProfil();

echo $user1->envoyerEmail("Bienvenue", "Merci de vous être inscrit !");
?>

6. Instanciation et manipulation d'objets

Créer et utiliser plusieurs objets

<?php
// Créer un tableau d'utilisateurs
$utilisateurs = [];

$utilisateurs[] = new Utilisateur(1, "Dupont", "Jean", "jean@example.com");
$utilisateurs[] = new Utilisateur(2, "Martin", "Marie", "marie@example.com");
$utilisateurs[] = new Utilisateur(3, "Durand", "Paul", "paul@example.com");

// Afficher tous les utilisateurs
foreach ($utilisateurs as $user) {
    $user->afficherProfil();
}

// Compter les utilisateurs
echo "Total : " . count($utilisateurs) . " utilisateurs";
?>

Vérifier le type d'un objet

<?php
$user = new Utilisateur(1, "Test", "User", "test@example.com");

// Vérifier si c'est un objet
var_dump(is_object($user)); // true

// Vérifier la classe de l'objet
var_dump($user instanceof Utilisateur); // true

// Obtenir le nom de la classe
echo get_class($user); // Utilisateur

// Lister toutes les propriétés
print_r(get_object_vars($user));

// Lister toutes les méthodes
print_r(get_class_methods('Utilisateur'));
?>

7. Bonnes pratiques POO

Nommage

  • Classes : PascalCase (Utilisateur, ArticleManager)
  • Méthodes : camelCase (getNom, envoyerEmail)
  • Propriétés : camelCase ($nom, $dateCreation)
  • Un fichier = Une classe

Organisation

  • Propriétés en haut de la classe
  • Constructeur juste après
  • Méthodes publiques
  • Méthodes privées en dernier

Responsabilités

  • Une classe = une responsabilité claire
  • Méthodes courtes et focalisées
  • Éviter les dépendances complexes
  • Privilégier la réutilisation

Sécurité

  • Valider les données dans le constructeur
  • htmlspecialchars() à l'affichage
  • Ne pas exposer de données sensibles
  • Filtrer les entrées utilisateur
Froggiesplaining :


Objectifs de ce cours :
✅ Comprendre la différence entre classe et objet
✅ Créer des classes avec propriétés et méthodes
✅ Utiliser le constructeur __construct()
✅ Maîtriser $this pour accéder aux propriétés
✅ Instancier plusieurs objets indépendants

Points clés à retenir :
Classe = Le plan/modèle (comme un plan génétique des grenouilles)
Objet = Une instance réelle de la classe (une grenouille particulière)
Propriétés = Les caractéristiques (nom, couleur, âge)
Méthodes = Les actions possibles (sauter(), coasser(), nager())
$this = Référence à l'objet courant ("moi-même")
Constructeur = Méthode appelée automatiquement à la création (new)
• La POO permet d'organiser le code de manière réutilisable et maintenable

Exercice pratique :
1. Créer une classe Grenouille avec propriétés: nom, couleur, âge
2. Ajouter un constructeur pour initialiser ces propriétés
3. Créer une méthode coasser() qui affiche "Ribbit !"
4. Instancier 3 grenouilles différentes avec des caractéristiques variées
5. Faire coasser chaque grenouille et afficher leurs infos
6. Conseil de Froggie: La POO c'est comme un moule à gaufres (classe) qui crée plein de gaufres différentes (objets) avec des garnitures variées (propriétés) !

Froggie explain

GitHub - eCrea