PHP - Semaine 4 Jour 1 : Introduction à la POO

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

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

1. Qu'est-ce que la POO ?

Programmation Procédurale vs POO

Procédurale (classique)

POO (Orientée Objet)

2. Classes et Objets

Créer une classe

Créer des objets (instances)

Résultat :

Vocabulaire POO :

3. Le constructeur __construct()

Initialiser un objet automatiquement

Résultat :

Constructeur avec valeurs par défaut

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

Comprendre $this

5. Exemple complet : Classe Utilisateur

Application pratique

6. Instanciation et manipulation d'objets

Créer et utiliser plusieurs objets

Vérifier le type d'un objet

7. Bonnes pratiques POO

Nommage

Organisation

Responsabilités

Sécurité