Examen de Révision

Ce document est un examen de révision portant sur la conception orientée objet et la programmation Java, appliqué à la gestion simplifiée d’un hôpital. Il teste les compétences en manipulation des classes, collections (ArrayList, HashSet, HashMap), utilisation des API Stream et lambda expressions, ainsi que la bonne implémentation des méthodes equals, toString et gestion des doublons.

Exercice 1 : Compléter la classe Patient

Il s'agit de compléter les méthodes toString() et equals(Object obj) dans la classe Patient, en respectant la condition que deux patients sont égaux si leurs cin et numSecuriteSociale sont identiques.

1. Compléter la méthode toString()

La méthode toString() doit retourner une représentation textuelle complète du patient, incluant cin, nom, prénom et numéro de sécurité sociale.

public String toString() {
    return "Patient{" +
           "cin=" + cin +
           ", nom='" + nom + '\'' +
           ", prenom='" + prenom + '\'' +
           ", numSecuriteSociale=" + numSecuriteSociale +
           '}';
}

Réponse : La méthode toString() affiche les attributs du patient sous forme lisible.

2. Compléter la méthode equals(Object obj)

La méthode equals doit vérifier si l’objet passé est un Patient, puis comparer les attributs cin et numSecuriteSociale pour déterminer l’égalité.

public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Patient other = (Patient) obj;
    return this.cin == other.cin && this.numSecuriteSociale == other.numSecuriteSociale;
}

Réponse : Deux patients sont égaux si leurs cin et numSecuriteSociale sont identiques.

Exercice 2 : Compléter la classe ListPatients

Il faut compléter la classe ListPatients qui implémente InterfacePatient, en utilisant un ArrayList pour stocker les patients. Les méthodes à compléter sont le constructeur, l’ajout, la suppression, la recherche (par Patient et par cin), l’affichage, le tri par nom, et l’affichage sans redondance.

3. Déclaration de la classe ListPatients

La classe doit implémenter l’interface InterfacePatient.

public class ListPatients implements InterfacePatient {

Réponse : La classe implémente InterfacePatient.

4. Constructeur initialisant la liste

public ListPatients(){
    listP = new ArrayList<>();
}

Réponse : Le constructeur initialise listP en ArrayList vide.

5. Méthode ajouterPatient(Patient p)

public void ajouterPatient(Patient p) {
    listP.add(p);
}

Réponse : Le patient est ajouté à la liste.

6. Méthode supprimerPatient(Patient p)

public void supprimerPatient(Patient p) {
    listP.remove(p);
}

Réponse : Le patient est supprimé de la liste.

7. Méthode rechercherPatient(Patient p) avec API Stream

public boolean rechercherPatient(Patient p){
    return listP.stream().anyMatch(patient -> patient.equals(p));
}

Réponse : Recherche si un patient égal à p est présent dans la liste.

8. Méthode rechercherPatient(int cin) avec API Stream

public boolean rechercherPatient(int cin) {
    return listP.stream().anyMatch(patient -> patient.getCin() == cin);
}

Réponse : Recherche si un patient avec le cin donné est présent.

9. Méthode afficherPatients() avec lambda expression

public void afficherPatients() {
    listP.forEach(patient -> System.out.println(patient));
}

Réponse : Affiche tous les patients de la liste.

10. Méthode trierPatientsParNom() avec API Stream

public void trierPatientsParNom() {
    listP = listP.stream()
                 .sorted(Comparator.comparing(Patient::getNom))
                 .collect(Collectors.toList());
}

Réponse : Trie la liste des patients par ordre alphabétique du nom.

11. Méthode PatientSansRedondance()

Afficher la liste des patients sans doublons (selon equals).

public void PatientSansRedondance(){
    listP.stream()
         .distinct()
         .forEach(System.out::println);
}

Réponse : Affiche les patients sans répétition.

Exercice 3 : Compléter la classe Medecin

Compléter les méthodes toString(), equals(Object obj) et hashCode() pour permettre la gestion correcte dans un HashSet.

11. Méthode toString()

public String toString() {
    return "Medecin{" +
           "cin=" + cin +
           ", nom='" + nom + '\'' +
           ", prenom='" + prenom + '\'' +
           ", numOrdre=" + numOrdre +
           '}';
}

Réponse : Affiche les informations du médecin.

12. Méthode equals(Object obj)

Deux médecins sont égaux si leur cin et numOrdre sont identiques (hypothèse logique).

public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Medecin other = (Medecin) obj;
    return this.cin == other.cin && this.numOrdre == other.numOrdre;
}

Réponse : Définition de l’égalité entre médecins.

13. Méthode hashCode()

Pour que HashSet fonctionne correctement, il faut redéfinir hashCode en cohérence avec equals.

public int hashCode() {
    return Objects.hash(cin, numOrdre);
}

Réponse : HashCode basé sur cin et numOrdre.

Exercice 4 : Compléter la classe SetMedecins

Compléter le constructeur, les méthodes d’ajout, recherche, affichage, comptage et tri des médecins dans un HashSet.

14. Constructeur initialisant le HashSet

public SetMedecins(){
    setM = new HashSet<>();
}

Réponse : Initialisation de setM.

15. Méthode ajouterMedecin(Medecin m)

public void ajouterMedecin(Medecin m) {
    setM.add(m);
}

Réponse : Ajoute un médecin au HashSet, sans doublons grâce à equals et hashCode.

16. Méthode rechercherMedecin(int cin) avec API Stream

public boolean rechercherMedecin(int cin) {
    return setM.stream().anyMatch(medecin -> medecin.getCin() == cin);
}

Réponse : Recherche un médecin par cin.

17. Méthode afficherMedecins() avec lambda expression

public void afficherMedecins() {
    setM.forEach(System.out::println);
}

Réponse : Affiche tous les médecins du set.

18. Méthode nombreMedecins() avec API Stream

public long nombreMedecins(){
    return setM.stream().count();
}

Réponse : Retourne le nombre de médecins dans le set.

19. Méthode trierMedecins() avec API Stream

Retourne un TreeSet trié des médecins. Le tri se fait par nom, puis prénom (hypothèse classique).

public TreeSet<Medecin> trierMedecins(){
    return setM.stream()
               .sorted(Comparator.comparing(Medecin::getNom)
                                 .thenComparing(Medecin::getPrenom))
               .collect(Collectors.toCollection(TreeSet::new));
}

Réponse : Retourne un TreeSet trié par nom puis prénom.

Exercice 5 : Compléter la classe Hopital

Compléter la gestion d’une Map associant chaque médecin à sa liste de patients.

18. Constructeur initialisant la Map

public Hopital(){
    medecinPatiens = new HashMap<>();
}

Réponse : Initialisation de la HashMap.

19. Méthode ajouterMedecin(Medecin m)

public void ajouterMedecin(Medecin m){
    medecinPatiens.putIfAbsent(m, new ListPatients());
}

Réponse : Ajoute un médecin avec une liste vide de patients si absent.

20. Méthode ajouterPatient(Medecin m, Patient p) si le médecin existe

if(medecinPatiens.containsKey(m)){
    medecinPatiens.get(m).ajouterPatient(p);
}

Réponse : Ajoute le patient à la liste du médecin existant.

21. Méthode ajouterPatient(Medecin m, Patient p) sinon

else {
    ListPatients lp = new ListPatients();
    lp.ajouterPatient(p);
    medecinPatiens.put(m, lp);
}

Réponse : Crée une nouvelle liste pour le médecin et y ajoute le patient.

22. Méthode afficherMap() avec lambda expression

public void afficherMap(){
    medecinPatiens.forEach((medecin, patients) -> {
        System.out.println(medecin);
        patients.afficherPatients();
    });
}

Réponse : Affiche chaque médecin suivi de ses patients.

23. Méthode afficherMedcinPatients(Medecin m)

public void afficherMedcinPatients(Medecin m){
    if(medecinPatiens.containsKey(m)){
        medecinPatiens.get(m).afficherPatients();
    } else {
        System.out.println("Médecin non trouvé");
    }
}

Réponse : Affiche les patients du médecin donné ou un message si absent.

24. Méthode RetournerNomPatients() pour patients avec numSecuriteSociale = 1

public List<String> RetournerNomPatients (){
    return medecinPatiens.values().stream()
        .flatMap(listPatients -> listPatients.listP.stream())
        .filter(patient -> patient.getNumSecuriteSociale() == 1)
        .map(Patient::getNom)
        .collect(Collectors.toList());
}

Réponse : Retourne la liste des noms des patients ayant numSecuriteSociale égal à 1.

Méthode : Techniques récompensées et erreurs pénalisées

• Respect strict des signatures et conventions données : utiliser exactement les noms de méthodes, attributs et types fournis.
• Implémentation correcte des méthodes equals et hashCode pour garantir la gestion des doublons dans HashSet et HashMap.
• Utilisation appropriée des collections Java : ArrayList pour ListPatients, HashSet pour SetMedecins, HashMap pour Hopital.
• Maîtrise des API Stream et lambda expressions pour les opérations de recherche, tri, filtrage et affichage.
• Ne pas réécrire le code donné, ne compléter que les parties demandées.
• Gestion des cas d’absence (exemple : vérifier la présence d’un médecin avant d’ajouter un patient).
• Affichage clair et complet des objets via toString.
• Attention aux fautes d’orthographe dans les noms de variables (ex : medecinPatiens doit rester tel quel).
• Ne pas inventer de données ou méthodes non présentes dans l’énoncé.

Les erreurs fréquentes pénalisées sont : ne pas redéfinir hashCode avec equals, oublier d’initialiser les collections, mauvaise gestion des doublons, ou absence d’utilisation des API Stream quand demandé.