POO à l'examen : méthode, exercices corrigés et aide-mémoire

class Portable
{
    private readonly List<Pret> lesPrets = new List<Pret>();

    public Portable(string numInventaire, string marque)
    {
        NumInventaire = numInventaire;
        Marque = marque;
    }

    public string NumInventaire { get; }
    public string Marque { get; }
    public IReadOnlyList<Pret> LesPrets => lesPrets;

    public bool EstDisponible()
    {
        foreach (Pret p in lesPrets)
        {
            if (p.EstEnCours())
            {
                return false;
            }
        }
        return true;
    }

    public Pret Preter(Salarie salarie, DateOnly debut, DateOnly retourPrevu)
    {
        if (!EstDisponible())
        {
            throw new InvalidOperationException($"Le portable {NumInventaire} est déjà prêté.");
        }
        Pret p = new Pret(this, salarie, debut, retourPrevu);
        lesPrets.Add(p);
        return p;
    }
}

class Pret
{
    internal Pret(Portable portable, Salarie salarie, DateOnly debut, DateOnly retourPrevu)
    {
        if (retourPrevu < debut)
        {
            throw new ArgumentException("Le retour prévu précède le début du prêt.");
        }
        LePortable = portable;
        LeSalarie = salarie;
        DateDebut = debut;
        DateRetourPrevue = retourPrevu;
    }

    public Portable LePortable { get; }
    public Salarie LeSalarie { get; }
    public DateOnly DateDebut { get; }
    public DateOnly DateRetourPrevue { get; }
    public DateOnly? DateRetourReelle { get; private set; }
    public string? EtatRetour { get; private set; }

    public bool EstEnCours() => DateRetourReelle is null;

    public void EnregistrerRetour(DateOnly date, string etat)
    {
        if (!EstEnCours())
        {
            throw new InvalidOperationException("Ce prêt est déjà clos.");
        }
        if (date < DateDebut)
        {
            throw new ArgumentException("Le retour précède le début du prêt.");
        }
        DateRetourReelle = date;
        EtatRetour = etat;
    }

    public bool EstEnRetard(DateOnly jour) => EstEnCours() && jour > DateRetourPrevue;

    public int JoursDeRetard(DateOnly jour) =>
        EstEnRetard(jour) ? jour.DayNumber - DateRetourPrevue.DayNumber : 0;
}

Le 2 novembre 2026 : EstDisponible() renvoie false (le prêt est en cours), EstEnRetard(jour) true, JoursDeRetard(jour) 10 (8 jours du 24 au 31 octobre, plus le 1er et le 2 novembre). DayNumber donne le numéro du jour depuis le 1er janvier de l'an 1 : la différence de deux DayNumber est un nombre de jours.

Ce qu'un correcteur regarde en priorité : les multiplicités [0..1] traduites en types nullables ; l'association 0..* en liste privée exposée en lecture seule ; Preter qui crée le prêt (le constructeur internal empêche de créer un prêt hors de Preter, donc hors de la liste) ; EstDisponible avec le return true après la boucle ; les dates de retour en private set, modifiées seulement par EnregistrerRetour.

public TimeSpan? DelaiResolution() => DateCloture - DateOuverture;

public Employe? TechnicienPrincipal() =>
    interventions.GroupBy(i => i.Technicien)
                 .OrderByDescending(g => g.Sum(i => i.DureeMin))
                 .Select(g => g.Key)
                 .FirstOrDefault();

Soustraire un DateTime d'un DateTime? nul donne null : la première méthode n'a pas besoin de if. Une version sans LINQ, plus proche de ce qu'on écrit en Java, cumule les durées dans un Dictionary<Employe, int>, puis cherche la plus grande valeur.

Résultats : DelaiResolution() vaut 06:45:00 (6 h 45, soit TotalHours = 6,75) ; TechnicienPrincipal() renvoie Moussa (90 minutes contre 40 + 30 = 70 pour Chloé). Le regroupement porte sur l'objet Employe : sans redéfinition d'Equals, deux objets différents pour la même personne compteraient comme deux techniciens (chapitre 11).

Les défauts :

1. Champs publics (Salle, Debut, Fin) : on peut déplacer une réservation sans aucune vérification.
2. Aucune validation : une fin antérieure au début est acceptée.
3. Liste exposée : Participants.Add(...) depuis l'extérieur contourne AjouterParticipant.
4. Donnée dérivée stockée : NbParticipants peut diverger de Participants.Count (et il est public en écriture).
5. Doublons et capacité : le même participant peut être ajouté deux fois, et rien ne limite le nombre de personnes.
6. Liste statique globale Toutes : la classe se range elle-même dans un registre global, ce qui mélange deux responsabilités, rend les tests dépendants les uns des autres et ne correspond à aucune persistance réelle. C'est le rôle d'un repository (chapitre 13).

public class Reservation
{
    private readonly HashSet<string> participants = new(StringComparer.OrdinalIgnoreCase);

    public Reservation(string salle, DateTime debut, DateTime fin, int capacite)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(salle);
        if (fin <= debut)
        {
            throw new ArgumentException("La fin doit être postérieure au début.");
        }
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(capacite);
        Salle = salle;
        Debut = debut;
        Fin = fin;
        Capacite = capacite;
    }

    public string Salle { get; }
    public DateTime Debut { get; }
    public DateTime Fin { get; }
    public int Capacite { get; }
    public IReadOnlyCollection<string> Participants => participants;
    public int NbParticipants => participants.Count;

    public void AjouterParticipant(string email)
    {
        if (participants.Count >= Capacite)
        {
            throw new InvalidOperationException($"La salle {Salle} est complète.");
        }
        participants.Add(email.Trim());
    }

    public bool Chevauche(Reservation autre) =>
        Salle == autre.Salle && Debut < autre.Fin && autre.Debut < Fin;
}

Le HashSet avec un comparateur insensible à la casse élimine les doublons d'adresse. Chevauche était juste : deux créneaux se chevauchent si chacun commence avant la fin de l'autre ; une réservation de 9 h à 10 h 30 et une de 10 h 30 à 11 h ne se chevauchent pas.

1. Abonnement déclare une méthode abstraite, coutAnnuel() : un abonnement « en général » ne sait pas calculer son coût, seules les classes filles le savent. Une classe qui a une méthode abstraite doit être abstraite. new Abonnement("Test", 10) ne compile pas : on n'instancie pas une classe abstraite.
2. Le polymorphisme (liaison dynamique) : this.coutAnnuel() exécute la version de la classe réelle de l'objet. En Java, toutes les méthodes sont redéfinissables par défaut, sans mot-clé virtual.
3. textCopier le code de la réponse de l'exercice 4

   Messagerie : 150.0 €
   Sauvegarde en ligne : 180.0 €
   Antivirus : 48.0 €
   

   12,5 × 12 = 150 ; 20 × 12 × 75 / 100 = 180 ; 4 × 12 × 100 / 100 = 48. Java affiche un double avec un point et au moins une décimale : 150.0.
4. javaCopier le code de la réponse de l'exercice 4

   public static double coutTotal(ArrayList<Abonnement> lesAbonnements) {
       double total = 0;
       for (Abonnement unAbonnement : lesAbonnements) {
           total = total + unAbonnement.coutAnnuel();
       }
       return total;
   }
   

   Valeur : 378.0 (150 + 180 + 48). La boucle ne teste pas le type de l'abonnement : chaque objet calcule son propre coût.

1. Une classe est un plan qui décrit des données et des méthodes ; un objet est un exemplaire créé à partir de ce plan avec new, qui a ses propres valeurs.
2. Il initialise un objet au moment de sa création et garantit qu'il naît valide, en exigeant et en vérifiant les données obligatoires.
3. Cacher les données d'un objet et n'y donner accès que par des membres qui contrôlent : champs private, propriétés avec un set qui valide ou absent, méthodes métier.
4. Un membre private n'est accessible que dans sa classe ; un membre protected l'est aussi dans les classes filles.
5. La surcharge, ce sont plusieurs méthodes de même nom avec des paramètres différents, choisies à la compilation ; la redéfinition, c'est une classe fille qui remplace (override) une méthode virtual de même signature, choisie à l'exécution selon l'objet réel.
6. Une interface n'est qu'un contrat, sans implémentation ni état : il n'y a rien à construire. On instancie une classe qui l'implémente.
7. Quand on veut exprimer une capacité partagée par des classes sans lien de nature, ou permettre à une classe d'en adopter plusieurs ; la classe abstraite convient à une famille d'objets qui partagent un état et du code.
8. Dans les deux cas, un tout contient des parties ; dans une composition, les parties n'existent pas sans le tout et disparaissent avec lui (un ticket et ses interventions), dans une agrégation, elles lui survivent (un service et ses employés).
9. Dictionary et HashSet rangent les objets d'après leur code de hachage avant de les comparer avec Equals : deux objets égaux doivent avoir le même code, sinon ils ne sont jamais comparés et les recherches échouent.
10. Fournir à une classe, par son constructeur, les objets dont elle dépend, au lieu de la laisser les créer ; elle ne dépend plus que d'interfaces, ce qui permet de changer d'implémentation (MySQL, mémoire) et de la tester avec des doublures.