Examen de Révision
Examen de Révision
Conception orientée objet et programmation Java · exam
Voir tous les documents en programmationTous les examens en programmation
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
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.
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.
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.
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.
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.
La classe doit implémenter l’interface InterfacePatient.
public class ListPatients implements InterfacePatient {
Réponse : La classe implémente InterfacePatient.
public ListPatients(){
listP = new ArrayList<>();
}
Réponse : Le constructeur initialise listP en ArrayList vide.
public void ajouterPatient(Patient p) {
listP.add(p);
}
Réponse : Le patient est ajouté à la liste.
public void supprimerPatient(Patient p) {
listP.remove(p);
}
Réponse : Le patient est supprimé de la liste.
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.
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.
public void afficherPatients() {
listP.forEach(patient -> System.out.println(patient));
}
Réponse : Affiche tous les patients de la liste.
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.
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.
Compléter les méthodes toString(), equals(Object obj) et hashCode() pour permettre la gestion correcte dans un HashSet.
public String toString() {
return "Medecin{" +
"cin=" + cin +
", nom='" + nom + '\'' +
", prenom='" + prenom + '\'' +
", numOrdre=" + numOrdre +
'}';
}
Réponse : Affiche les informations du médecin.
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.
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.
Compléter le constructeur, les méthodes d’ajout, recherche, affichage, comptage et tri des médecins dans un HashSet.
public SetMedecins(){
setM = new HashSet<>();
}
Réponse : Initialisation de setM.
public void ajouterMedecin(Medecin m) {
setM.add(m);
}
Réponse : Ajoute un médecin au HashSet, sans doublons grâce à equals et hashCode.
public boolean rechercherMedecin(int cin) {
return setM.stream().anyMatch(medecin -> medecin.getCin() == cin);
}
Réponse : Recherche un médecin par cin.
public void afficherMedecins() {
setM.forEach(System.out::println);
}
Réponse : Affiche tous les médecins du set.
public long nombreMedecins(){
return setM.stream().count();
}
Réponse : Retourne le nombre de médecins dans le set.
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.
Compléter la gestion d’une Map associant chaque médecin à sa liste de patients.
public Hopital(){
medecinPatiens = new HashMap<>();
}
Réponse : Initialisation de la HashMap.
public void ajouterMedecin(Medecin m){
medecinPatiens.putIfAbsent(m, new ListPatients());
}
Réponse : Ajoute un médecin avec une liste vide de patients si absent.
if(medecinPatiens.containsKey(m)){
medecinPatiens.get(m).ajouterPatient(p);
}
Réponse : Ajoute le patient à la liste du médecin existant.
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.
public void afficherMap(){
medecinPatiens.forEach((medecin, patients) -> {
System.out.println(medecin);
patients.afficherPatients();
});
}
Réponse : Affiche chaque médecin suivi de ses patients.
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.
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.
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é.