Exercices corrigés PHP – Programmation Orientée Objet | Partie 3

<?php
// Définir la classe Produit
class Produit {
    // Champ privé pour stocker le nom du produit
    private $nom;
    // Champ privé pour stocker la quantité du produit
    private $quantite;

    // Constructeur pour initialiser le nom et la quantité du produit
    public function __construct($nom, $quantite) {
        $this->nom = $nom;
        $this->quantite = $quantite;
    }

    // Méthode pour obtenir le nom du produit
    public function getNom() {
        return $this->nom;
    }

    // Méthode pour définir le champ nom
    public function setNom($nom) {
        $this->nom = $nom;
    }

    // Méthode pour obtenir la quantité du produit
    public function getQuantite() {
        return $this->quantite;
    }

    // Méthode pour définir le champ quantite
    public function setQuantite($quantite) {
        $this->quantite = $quantite;
    }
}

// Définir la classe Stock
class Stock {
    // Champ privé pour stocker une liste d'objets Produit
    private $produits;

    // Constructeur pour initialiser le champ produits
    public function __construct() {
        $this->produits = array();
    }

    // Méthode pour ajouter un produit à la liste des produits
    public function addProduit(Produit $produit) {
        $this->produits[] = $produit;
    }

    // Méthode pour supprimer un produit de la liste des produits
    public function removeProduit(Produit $produit) {
        foreach ($this->produits as $key => $p) {
            if ($p->getNom() === $produit->getNom()) {
                unset($this->produits[$key]);
            }
        }
    }

    // Méthode pour vérifier si les produits en stock sont 
    // insuffisants
    public function checkStock() {
        foreach ($this->produits as $produit) {
            if ($produit->getQuantite() <= 100) {
                echo $produit->getNom() . " est en rupture de stock. La quantité actuelle: " . $produit->getQuantite() . "\n";
            }
        }
    }
}


// Créer une nouvelle instance de la classe Stock
$stock = new Stock();

// Créer de nouveaux objets Produit avec nom et quantité
$p1 = new Produit("Souris", 300);
$p2 = new Produit("Clavier", 70);
$p3 = new Produit("Tablette", 40);

echo "Ajouter trois produits en stock:\n";
$stock->addProduit($p1);
$stock->addProduit($p2);
$stock->addProduit($p3);

echo "\nVérifier la disponibilité des stocks:\n";
$stock->checkStock();

echo "\nSupprimer la tablette du stock!\n";
$stock->removeProduit($p3);

echo "\nVérifier à nouveau la disponibilité des stocks:\n";
$stock->checkStock();
?>

Sortie:

Ajouter trois produits en stock:

Vérifier la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70
Tablette est en rupture de stock. La quantité actuelle: 40

Supprimer la tablette du stock!

Vérifier à nouveau la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70

<?php
// Définir la classe Etudiant
class Etudiant {
    private $nom;
    private $age;

    public function __construct($nom, $age) {
        $this->nom = $nom;
        $this->age = $age;
    }

    public function getNom() {
        return $this->nom;
    }

    public function setNom($nom) {
        $this->nom = $nom;
    }

    public function getAge() {
        return $this->age;
    }

    public function setAge($age) {
        $this->age = $age;
    }
}

// Définir la classe Enseignant
class Enseignant {
    private $nom;
    private $matiere;

    public function __construct($nom, $matiere) {
        $this->nom = $nom;
        $this->matiere = $matiere;
    }

    public function getNom() {
        return $this->nom;
    }

    public function setNom($nom) {
        $this->nom = $nom;
    }

    public function getMatiere() {
        return $this->matiere;
    }

    public function setMatiere($matiere) {
        $this->matiere = $matiere;
    }
}

// Définir la classe Classe
class Classe {
    private $nomClasse;
    private $enseignant;
    private $etudiants;

    public function __construct($nomClasse, Enseignant $enseignant) {
        $this->nomClasse = $nomClasse;
        $this->enseignant = $enseignant;
        $this->etudiants = array();
    }

    public function getNomClasse() {
        return $this->nomClasse;
    }

    public function setNomClasse($nomClasse) {
        $this->nomClasse = $nomClasse;
    }

    public function getEnseignant() {
        return $this->enseignant;
    }

    public function setEnseignant(Enseignant $enseignant) {
        $this->enseignant = $enseignant;
    }

    public function getEtudiants() {
        return $this->etudiants;
    }

    public function addEtudiant(Etudiant $etudiant) {
        $this->etudiants[] = $etudiant;
    }

    public function removeEtudiant(Etudiant $etudiant) {
        foreach ($this->etudiants as $key => $e) {
            if ($e->getNom() === $etudiant->getNom()) {
                unset($this->etudiants[$key]);
            }
        }
    }
}

// Définir la classe Ecole
class Ecole {
    private $etudiants;
    private $enseignants;
    private $classes;

    public function __construct() {
        $this->etudiants = array();
        $this->enseignants = array();
        $this->classes = array();
    }

    public function addEtudiant(Etudiant $etudiant) {
        $this->etudiants[] = $etudiant;
    }

    public function removeEtudiant(Etudiant $etudiant) {
        foreach ($this->etudiants as $key => $e) {
            if ($e->getNom() === $etudiant->getNom()) {
                unset($this->etudiants[$key]);
            }
        }
    }

    public function addEnseignant(Enseignant $enseignant) {
        $this->enseignants[] = $enseignant;
    }

    public function removeEnseignant(Enseignant $enseignant) {
        foreach ($this->enseignants as $key => $e) {
            if ($e->getNom() === $enseignant->getNom()) {
                unset($this->enseignants[$key]);
            }
        }
    }

    public function addClasse(Classe $classe) {
        $this->classes[] = $classe;
    }

    public function removeClasse(Classe $classe) {
        foreach ($this->classes as $key => $c) {
            if ($c->getNomClasse() === $classe->getNomClasse()) {
                unset($this->classes[$key]);
            }
        }
    }

    public function getEtudiants() {
        return $this->etudiants;
    }

    public function getEnseignants() {
        return $this->enseignants;
    }

    public function getClasses() {
        return $this->classes;
    }
}


// Créer une nouvelle instance de Ecole
$ecole = new Ecole();

// Créer des objets Etudiant
$et1 = new Etudiant("Alex Babtise", 20);
$et2 = new Etudiant("Bob Firok", 25);
$et3 = new Etudiant("Emily Taylor", 22);
$et4 = new Etudiant("Ali Binani", 23);

// Ajouter les étudiants à l'école
$ecole->addEtudiant($et1);
$ecole->addEtudiant($et2);
$ecole->addEtudiant($et3);
$ecole->addEtudiant($et4);

// Créer des objets Enseignant
$es1 = new Enseignant("Yohan Sinor", "Math");
$es2 = new Enseignant("Thomas Fiza", "Anglais");
$es3 = new Enseignant("Olivier Bibo", "Science");

// Ajouter les enseignants à l'école
$ecole->addEnseignant($es1);
$ecole->addEnseignant($es2);
$ecole->addEnseignant($es3);

// Créer des objets Classe
$classMath = new Classe("Mathematics", $es1);
$classAnglais = new Classe("Anglais", $es2);
$classScience = new Classe("Science", $es3);

// Ajouter des étudiants aux classes
$classMath->addEtudiant($et1);
$classMath->addEtudiant($et2);
$classMath->addEtudiant($et3);
$classMath->addEtudiant($et4);

$classAnglais->addEtudiant($et1);
$classAnglais->addEtudiant($et2);
$classAnglais->addEtudiant($et3);

$classScience->addEtudiant($et1);
$classScience->addEtudiant($et2);
$classScience->addEtudiant($et3);
$classScience->addEtudiant($et4);

// Ajouter les classes à l'école
$ecole->addClasse($classMath);
$ecole->addClasse($classAnglais);
$ecole->addClasse($classScience);

// Afficher des informations générales sur l'école
echo "Informations sur l'école:\n";
echo "Nombre d'étudiants: " . count($ecole->getEtudiants()) . "\n";
echo "Nombre d'enseignants: " . count($ecole->getEnseignants()) . "\n";
echo "Nombre de classes: " . count($ecole->getClasses()) . "\n\n";

// Afficher les informations sur les cours de mathématiques
echo "Informations sur les cours de mathématiques:\n";
echo "Nom de classe: " . $classMath->getNomClasse() . "\n";
echo "Enseignant: " . $classMath->getEnseignant()->getNom() . "\n";
echo "Nombre d'étudiants: " . count($classMath->getEtudiants()) . "\n\n";

// Supprimer un élève, un enseignant et une classe
$ecole->removeEtudiant($et1);
$ecole->removeEnseignant($es2);
$ecole->removeClasse($classMath);

// Afficher les informations mises à jour après suppression
echo "Informations sur l'école après suppression:\n";
echo "Nombre d'étudiants: " . count($ecole->getEtudiants()) . "\n";
echo "Nombre d'enseignants: " . count($ecole->getEnseignants()) . "\n";
echo "Nombre de classes: " . count($ecole->getClasses()) . "\n";
?>

Sortie:

Informations sur l'école:
Nombre d'étudiants: 4
Nombre d'enseignants: 3
Nombre de classes: 3

Informations sur les cours de mathématiques:
Nom de Class: Mathematics
Enseignant: Yohan Sinor
Nombre d'étudiants: 4

Informations sur les cours d'anglais:
Nom de Class: Anglais
Enseignant: Thomas Fiza
Nombre d'étudiants: 3

Informations sur les cours de sciences:
Nom de Class: Science
Enseignant: Olivier Bibo
Nombre d'étudiants: 4

Informations sur l'école après suppression d'un élève, d'un enseignant et d'une classe:
Nombre d'étudiants: 3
Nombre d'enseignants: 2
Nombre de classes: 2

<?php
// Définir la classe Chanson
class Chanson {
    // Champs privés pour stocker le titre et l'artiste de la chanson
    private $title;
    private $artist;

    // Constructeur pour initialiser les champs titre et artiste
    public function __construct($title, $artist) {
        // Définir le champ titre avec le titre fourni
        $this->title = $title;
        // Définir le champ artist avec l'artiste fourni
        $this->artist = $artist;
    }

    // Méthode Getter pour récupérer le titre de la chanson
    public function getTitre() {
        // Retourner la valeur du champ titre
        return $this->title;
    }

    // Méthode pour modifier le titre de la chanson
    public function setTitre($title) {
        // Définir le champ titre avec le titre fourni
        $this->title = $title;
    }

    // Méthode Getter pour récupérer l'artiste de la chanson
    public function getArtist() {
        // Retourner la valeur du champ artist
        return $this->artist;
    }

    // Méthode pour modifier le nom de l'artiste de la chanson
    public function setArtist($artist) {
        // Définir le champ artist avec l'artiste fourni
        $this->artist = $artist;
    }
}

// Définir la classe BiblioMusicale
class BiblioMusicale {
    // Déclarer un champ privé pour stocker une liste de chansons
    private $chansons;

    // Constructeur pour initialiser la liste des chansons
    public function __construct() {
        // Créer une nouvelle liste pour stocker les objets Chanson
        $this->chansons = [];
    }

    // Méthode pour ajouter une chanson à la bibliothèque
    public function addChanson($song) {
        // Ajouter la chanson fournie à la liste des chansons
        $this->chansons[] = $song;
    }

    // Méthode pour supprimer une chanson de la bibliothèque
    public function removeChanson($song) {
        // Supprimer la chanson fournie de la liste des chansons
        foreach ($this->chansons as $key => $value) {
            if ($value === $song) {
                unset($this->chansons[$key]);
            }
        }
    }

    // Méthode pour obtenir la liste de toutes les chansons de la 
    // bibliothèque
    public function getChanson() {
        // Retourner la liste des chansons
        return $this->chansons;
    }

    // Méthode pour lire une chanson aléatoire de la bibliothèque
    public function lireChansonAleatoire() {
        // Récupérer le nombre de chansons dans la bibliothèque
        $size = count($this->chansons);

        // Vérifier si la bibliothèque est vide
        if ($size === 0) {
            // Afficher un message s'il n'y a pas de chansons à lire
            echo "Il n'y a pas de chansons à lire.\n";
            return; // Quitter la méthode
        }

        // Générer un index aléatoire dans l'intervalle de la liste
        // des chansons
        $index = rand(0, $size - 1);

        // Afficher le titre et l'artiste de la chanson sélectionnée 
        // de manière aléatoire
        echo "Lire: " . $this->chansons[$index]->getTitre() . " par " . $this->chansons[$index]->getArtist() . "\n";
    }
}


// Créer une nouvelle instance de la classe BiblioMusicale
$biblio = new BiblioMusicale();

// Ajouter des chansons à la bibliothèque musicale
$biblio->addChanson(new Chanson("Un clair de lune", "Jean Chérasse"));
$biblio->addChanson(new Chanson("Cadet Rousselle", "André Hunebelle"));
$biblio->addChanson(new Chanson("Help!", "Richard Lester"));
$biblio->addChanson(new Chanson("Baisers volés", "François Truffaut"));
$biblio->addChanson(new Chanson("Je t'aime", "Serge Gainsbourg"));
$biblio->addChanson(new Chanson("Staying Alive", "Michel Blanc"));

// Afficher toutes les chansons de la bibliothèque musicale
echo "Toutes les chansons:\n";

// Parcourir chaque chanson de la bibliothèque et afficher son titre et son artiste
foreach ($biblio->getChanson() as $chanson) {
    echo $chanson->getTitre() . " par " . $chanson->getArtist() . "\n";
}

echo "\nLecture d'une chanson aléatoire:\n";

// Lire et afficher trois fois une chanson choisie au hasard dans la bibliothèque
$biblio->lireChansonAleatoire();
echo "\n";
$biblio->lireChansonAleatoire();
echo "\n";
$biblio->lireChansonAleatoire();

?>

Sortie:

Toutes les chansons:
Un clair de lune par Jean Chérasse
Cadet Rousselle par André Hunebelle
Help! par Richard Lester
Baisers volés par François Truffaut
Je t'aime par Serge Gainsbourg
Staying Alive par Michel Blanc

Lecture d'une chanson aléatoire:
Lire: Help! par Richard Lester

Lire: Baisers volés par François Truffaut

Lire: Help! par Richard Lester

<?php
// Définir la classe Forme comme une classe abstraite
abstract class Forme {
    // Méthode abstraite pour récupérer la surface de la forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    public abstract function getSurface();

    // Méthode abstraite permettant d'obtenir le périmètre de la 
    // forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    public abstract function getPerimeter();
}

// Définir la classe Rectangle, qui hérite de la classe Forme
class Rectangle extends Forme {
    // Champs privés pour stocker la longueur et la largeur du 
    // rectangle
    private $longueur;
    private $largeur;

    // Constructeur pour initialiser la longueur et la largeur du 
    // rectangle
    public function __construct($longueur, $largeur) {
        // Définir le champ longueur à la longueur fournie
        $this->longueur = $longueur;
        // Définir le champ largeur à la largeur fournie
        $this->largeur = $largeur;
    }

    // Méthode pour calculer et renvoyer la surface du rectangle
    public function getSurface() {
        // Calculer la surface en multipliant la longueur et la 
        // largeur
        return $this->longueur * $this->largeur;
    }

    // Méthode pour calculer et renvoyer le périmètre du rectangle
    public function getPerimeter() {
        // Calculer le périmètre à l'aide de la formule 2 * (longueur 
        // + largeur)
        return 2 * ($this->longueur + $this->largeur);
    }
}

// Définir la classe Cercle, qui hérite de la classe Forme
class Cercle extends Forme {
    // Champ privé pour stocker le rayon du cercle
    private $rayon;

    // Constructeur pour initialiser le rayon du cercle
    public function __construct($rayon) {
        // Attribuer au champ rayon le rayon fourni
        $this->rayon = $rayon;
    }

    // Méthode pour calculer et renvoyer la surface du cercle
    public function getSurface() {
        // Calculer la surface en utilisant la formule π * rayon^2
        return M_PI * $this->rayon * $this->rayon;
    }

    // Méthode pour calculer le périmètre du cercle
    public function getPerimeter() {
        // Calculer le périmètre en utilisant la formule 2*π*rayon
        return 2 * M_PI * $this->rayon;
    }
}

// Définir la classe Triangle, qui hérite de la classe Forme
class Triangle extends Forme {
    // Champs privés pour stocker les côtés du triangle
    private $c1;
    private $c2;
    private $c3;

    // Constructeur pour initialiser les côtés du triangle
    public function __construct($c1, $c2, $c3) {
        $this->c1 = $c1;
        $this->c2 = $c2;
        $this->c3 = $c3;
    }

    // Méthode pour calculer et renvoyer la surface du triangle
    public function getSurface() {
        // Calculer le semi-périmètre
        $s = ($this->c1 + $this->c2 + $this->c3) / 2;

        // Calculer la surface à l'aide de la formule de Heron
        return sqrt($s * ($s - $this->c1) * ($s - $this->c2) * ($s - $this->c3));
    }

    // Méthode pour calculer et renvoyer le périmètre du triangle
    public function getPerimeter() {
        // Calculer le périmètre en additionnant les côtés
        return $this->c1 + $this->c2 + $this->c3;
    }
}

// Créer un rectangle de longueur 15 et de largeur 20
$rectangle = new Rectangle(15, 20);

// Créer un cercle de rayon 5
$circle = new Cercle(5);

// Créer un triangle dont les côtés sont 5, 7 et 9
$triangle = new Triangle(5, 7, 9);

echo "\nSurface et périmètre de différentes formes:\n";

// Afficher les détails et calculs du rectangle
echo "\nRectangle:\n";
echo "Surface: " . $rectangle->getSurface() . "\n";
echo "Périmètre: " . $rectangle->getPerimeter() . "\n";

// Afficher les détails et calculs du cercle
echo "\nCercle:\n";
echo "Surface: " . $circle->getSurface() . "\n";
echo "Périmètre: " . $circle->getPerimeter() . "\n";

// Afficher les détails et calculs du triangle
echo "\nTriangle:\n";
echo "Surface: " . $triangle->getSurface() . "\n";
echo "Périmètre: " . $triangle->getPerimeter() . "\n";
?>

Sortie:

Surface et périmètre de différentes formes:

Rectangle:
Surface: 300.0
Périmètre: 70.0

Cercle:
Surface: 78.53981633974483
Périmètre: 31.41592653589793

Triangle:
Surface: 17.41228014936585
Périmètre: 21.0

<?php
// Définir la classe Film
class Film {
    // Champs privés pour stocker le titre, le directeur, les acteurs 
    // et les avis sur le film.
    private $titre;
    private $directeur;
    private $acteurs;
    private $avis;

    // Constructeur pour initialiser le titre, le directeur et les 
    // acteurs du film
    public function __construct($titre, $directeur, $acteurs) {
        $this->titre = $titre;
        $this->directeur = $directeur;
        $this->acteurs = $acteurs; // Acteurs est un tableau
        // Initialiser la liste des avis comme un tableau vide
        $this->avis = []; 
    }

    // Méthode pour ajouter un avis sur le film
    public function addAvis($a) {
        // Ajouter l'avis fourni à la liste des avis
       //Utiliser l'opérateur [] pour ajouter un élément à un tableau
        $this->avis[] = $a; 
    }

    // Méthode pour récupérer la liste de tous les avis du film
    public function getAvis() {
        // Renvoyer la liste des avis
        return $this->avis;
    }

    // Méthode pour récupérer le titre du film
    public function getTitre() {
        // Retourner la valeur du champ titre
        return $this->titre;
    }

    // Méthode pour récupérer le directeur du film
    public function getDirecteur() {
        // Retourner la valeur du champ directeur
        return $this->directeur;
    }

    // Méthode pour récupérer la liste des acteurs d'un film
    public function getActeurs() {
        // Retourner la liste des acteurs
        return $this->acteurs;
    }
}

// Définir la classe Avis
class Avis {
    // Champs privés pour stocker le texte de l'avis, le nom de 
    // l'avis et la note.
    private $textAvis;
    private $nomAvis;
    private $note;

    // Constructeur pour initialiser le texte de l'avis, le nom de 
    // l'avis et la note.
    public function __construct($textAvis, $nomAvis, $note) {
        $this->textAvis = $textAvis;
        $this->nomAvis = $nomAvis;
        $this->note = $note;
    }

    // Méthode pour récupérer le texte de l'avis
    public function getTextAvis() {
        // Retourner la valeur du champ textAvis
        return $this->textAvis;
    }

    // Méthode pour récupérer le nom de l'avis
    public function getNomAvis() {
        // Retourner la valeur du champ nomAvis
        return $this->nomAvis;
    }

    // Méthode pour récupérer la note
    public function getNote() {
        // Retourner la valeur du champ note
        return $this->note;
    }
}


// Créer un objet film
$f1 = new Film("La Roue", "Jean Servais", ["Pierre Pelletier", "Pierre Mondy"]);

// Créer des objets d'avis
$avis1 = new Avis("Excellent film!", "Alex Babtise", 5.0);
$avis2 = new Avis("Fortement recommandé!", "Jean Zino", 4.5);
$avis3 = new Avis("Un film magnifique", "Bob Polib", 4.0);

// Ajouter un avis sur f1
$f1->addAvis($avis1);
$f1->addAvis($avis2);
$f1->addAvis($avis3);

// Afficher tous les avis sur 'La Roue'
echo "\nAvis pour '" . $f1->getTitre() . "':\n";
foreach ($f1->getAvis() as $a) {
    echo $a->getTextAvis() . " par " . $a->getNomAvis() . " - " . $a->getNote() . "\n";
}
?>

Sortie:

Avis pour 'La Roue':
Excellent film! par Alex Babtise - 5.0
Fortement recommandé! par Jean Zino - 4.5
Un film magnifique par Bob Polib - 4.0