Exercice Java POO
Constructeur
Exercice 1 : Gestion de Livres (Classe Livre)
Objectifs :
- Créer une classe Livre avec des attributs, des méthodes et des
règles métier spécifiques.
- Utiliser des concepts POO (constructeurs, getters/setters), des
listes, des conditions et des streams.
- Gérer des valeurs auto-incrémentées (id) et des identifiants
uniques (isbn).
Attributs de la classe Livre
- id (auto-incrémenté, non modifiable après création).
- isbn (format "0000", 4 chiffres aléatoires uniques).
- titre (String).
- listeAuteurs (List<String>).
- nbExemplaires (int).
- prix (double).
Méthodes à implémenter
1. Constructeurs
- Constructeur par défaut : Initialise les attributs avec des
valeurs par défaut.
- id → auto-incrémenté.
- isbn → généré aléatoirement (unique).
- Constructeur avec argement ou paramétré (titre, listeAuteurs,
nbExemplaires, prix) :
- id et isbn générés automatiquement.
- Les autres champs sont initialisés avec les arguments fournis.
2. Getters/Setters
- Getters pour tous les attributs.
- Setters uniquement pour les champs modifiables (titre,
listeAuteurs, nbExemplaires, prix).
- Pas de setter pour id et isbn (ils sont fixes après création).
3. Méthodes fonctionnelles
- afficher() → Affiche tous les détails du livre (format libre,
mais lisible).
- rechercherParISBN(List<Livre> livreList, String isbn) →
- Prend une liste de livres et un ISBN en entrée.
- Retourne le Livre correspondant ou null si non trouvé.
- getLivresParAuteur(List<Livre> livreList, String auteur) →
- Retourne une liste de livres où l’auteur est présent dans
listeAuteurs.
4. Règles métier
- Génération de l'ISBN :
- Doit être unique (vérifier dans la liste existante avant
validation).
- Si un ISBN généré existe déjà, en regénérer un nouveau.
- Auto-incrémentation de l'id :
- Le premier livre a id = 1, le suivant id = 2, etc.
5. Méthode supplémentaire
- genererISBN(List<Livre> livresExistants) →
- Génère un ISBN aléatoire qui n'existe pas dans
livresExistants.
- Format : 4 chiffres ("1234", "0456", etc.).
Classe de test (TestMain)
1. Saisie utilisateur :
- Demander le nombre de livres à créer.
2. Création des livres :
- Si l'indice du livre est pair → utiliser le constructeur
paramétré (valeurs fixes ou aléatoires).
- Sinon → utiliser le constructeur par défaut puis modifier les
champs via setters.
3. Affichage : Afficher tous les livres créés.
4. Recherche par ISBN :
- Demander un ISBN à l’utilisateur.
- Si trouvé :
- Modifier nbExemplaires (+1 par exemple).
- Réafficher le livre mis à jour.
- Sinon : Afficher "ISBN non trouvé."
5. Recherche par auteur :
- Demander un nom d’auteur.
- Afficher ses livres ou "Aucun livre trouvé."
6. Augmentation de prix :
- Pour les livres vérifiant :
- nbExemplaires > 20 OU prix > 30000 → ajouter 5000 au prix.
- Afficher les livres modifiés.
Exercice 2 : Gestion d’Étudiants (Classe Étudiant)
Objectifs :
- Manipulation de classes, getters/setters, constructeurs, listes,
conditions, boucles et streams.
- Gestion de matricules uniques et de moyennes automatiques.
Attributs de la classe Étudiant :
- matricule (auto-incrémenté, format "ET-000", non modifiable).
- nom (String).
- prenom (String).
- listeNotes (List<Double>).
- moyenne (double, calculée automatiquement).
- anneeInscription (int).
Méthodes à implémenter :
1. Constructeurs :
- Un constructeur sans arguments initialisant les attributs par
défaut.
- Un constructeur avec arguments (sauf matricule et moyenne
générés automatiquement).
2. Getters/Setters :
- Uniquement pour nom, prenom, listeNotes, anneeInscription.
3. Fonctionnalités :
- afficher() : Affiche les détails de l’étudiant.
- rechercherParMatricule(List<Étudiant> liste, String
matricule) : Retourne l’étudiant correspondant ou null.
- getEtudiantsAdmis(List<Étudiant> liste, double seuil) :
Retourne la liste des étudiants avec moyenne >= seuil.
4. Règles métier :
- La moyenne est recalculée à chaque modification de
listeNotes.
- Le matricule est généré sous forme "ET-001", "ET-002", etc.
Classe de test (TestMain) :
1. Demander à l’utilisateur le nombre d’étudiants à créer.
2. Remplir une liste d’étudiants :
- Utiliser le constructeur avec arguments si l’indice est
impair.
- Sinon, utiliser le constructeur sans arguments (et remplir
les données manuellement).
3. Afficher tous les étudiants.
4. Rechercher un étudiant par matricule :
- Si trouvé, ajouter une note et recalculer la moyenne.
- Sinon, afficher un message d’erreur.
5. Afficher les étudiants admis (moyenne >= 10).
6. Augmenter de 1 l’anneeInscription des étudiants :
- Ayant moyenne < 5 OU anneeInscription < 2020.
Exercice 3 : Gestion de Produits (Classe Produit)
Objectifs :
- Manipulation de classes, getters/setters, validation de données,
gestion de codes uniques.
Attributs de la classe Produit :
- code (String, format "PRD-XXXX" aléatoire, unique).
- nom (String).
- prix (double, doit être > 0).
- quantiteStock (int).
- estEnPromo (boolean).
Méthodes à implémenter :
1. Constructeurs :
- Un constructeur sans arguments initialisant les attributs par
défaut.
- Un constructeur avec arguments (sauf code généré
automatiquement).
2. Getters/Setters :
- Avec validation : prix > 0, quantiteStock >= 0.
3. Fonctionnalités :
- afficher() : Affiche les détails du produit.
- rechercherParCode(List<Produit> liste, String code) :
Retourne le produit correspondant.
- appliquerPromo(double pourcentage) : Réduit le prix si
estEnPromo=true.
4. Règles métier :
- Le code doit être unique (vérification avant génération).
Classe de test (TestMain) :
1. Créer une liste de 5 produits (mélange constructeurs).
2. Afficher tous les produits.
3. Rechercher un produit par code :
- Si trouvé, basculer estEnPromo et appliquer une réduction de
10%.
4. Afficher les produits en rupture (quantiteStock = 0).
5. Augmenter le stock de 50% pour les produits :
- Ayant prix > 1000 ET estEnPromo=false.
Exercice 4 : Gestion de Tâches (Classe Tâche)
Objectifs :
- Gestion de priorités, dates, et statuts automatiques.
Attributs de la classe Tâche :
- id (auto-incrémenté).
- description (String).
- priorite (int, 1-3).
- dateCreation (de type Date, générée automatiquement).
- estTerminee (boolean).
Méthodes à implémenter :
1. Constructeurs :
- Un constructeur sans arguments initialisant les attributs par
défaut.
- Un constructeur avec arguments (sauf id et dateCreation).
2. Getters/Setters :
- Avec validation : priorite entre 1 et 3.
3. Fonctionnalités :
- afficher() : Affiche les détails de la tâche.
- marquerCommeTerminee() : Modifie estTerminee à true.
- filtrerTâches(List<Tâche> liste, int priorite) : Retourne les
tâches de priorité donnée.
4. Règles métier :
- dateCreation est la date système au moment de la création.
Classe de test (TestMain) :
1. Créer une liste de 4 tâches (mélange constructeurs).
2. Afficher toutes les tâches.
3. Marquer une tâche comme terminée (saisie manuelle de l’id).
4. Afficher les tâches non terminées.
5. Modifier la priorité à 1 pour les tâches :
- Créées il y a plus de 2 jours ET non terminées.
Exercice 5 : Gestion de Comptes Bancaires (Classe Compte)
Objectifs :
- Gestion de soldes, numéros de compte uniques, et opérations
bancaires.
Attributs de la classe Compte :
- numeroCompte (String, format "BANK-XXXX" aléatoire, unique).
- titulaire (String).
- solde (double).
- estBloque (boolean).
Méthodes à implémenter :
1. Constructeurs :
- Un constructeur sans arguments initialisant les attributs par
défaut.
- Un constructeur avec arguments (sauf numeroCompte généré
automatiquement).
2. Getters/Setters :
- solde ne peut pas être négatif sauf si estBloque=true.
3. Fonctionnalités :
- afficher() : Affiche les détails du compte.
- deposer(double montant) : Ajoute au solde.
- retirer(double montant) : Retire du solde si autorisé.
4. Règles métier :
- Un compte bloqué ne peut pas effectuer de retraits.
Classe de test (TestMain) :
1. Créer une liste de 3 comptes (mélange constructeurs).
2. Afficher tous les comptes.
3. Effectuer un dépôt (saisie manuelle du numéro de compte).
4. Afficher les comptes bloqués.
5. Bloquer les comptes :
- Ayant solde < -1000 OU titulaire = "INCONNU".
Exercice 6 : Système de Gestion d'Étudiants Amélioré
Objectifs :
● Créer une classe Etudiant avec des attributs, des méthodes et
des règles métier spécifiques.
● Utiliser des concepts POO (constructeurs, getters/setters),
des collections (Map), et des calculs automatiques.
● Gérer un système de numérotation automatique (matricule) et
des calculs de moyenne pondérée.
Attributs de la classe Etudiant :
● matricule (String format "ETU2023-001", auto-généré, non
modifiable).
● nom (String).
● prenom (String).
● notes (Map<String, Double>) - Association Matière → Note.
● moyenne (double, calculée automatiquement).
● absences (int).
Méthodes à implémenter :
1.Constructeurs :
○ Un constructeur avec arguments (nom, prenom) générant
automatiquement le matricule.
2.Getters/Setters :
○ Getters pour tous les attributs.
○ Setters uniquement pour les champs modifiables (nom,
prenom, notes).
3.Méthodes fonctionnelles :
○ calculerMoyenne() : Calcule la moyenne pondérée (Math×2,
Français×1.5, autres×1).
○ determinerMention() : Retourne "Passable" si 10≤moy<12,
"Assez Bien" si 12≤moy<14, "Bien" si ≥14.
○ ajouterAbsence() : Incrémente le compteur d'absences et
vérifie si >10% des cours (alerte).
○ afficherBulletin() : Affiche un format lisible avec
mention.
4.Règles métier :
○ Le matricule est généré automatiquement avec un numéro
séquentiel.
○ La moyenne est recalculée à chaque modification des
notes.
○ Une alerte doit être générée si les absences dépassent
10% des cours.
Classe de test (Main) :
1.Saisie utilisateur :
○ Demander les informations d'étudiants jusqu'à entrer
"FIN" comme nom.
○ Pour chaque étudiant, saisir nom, prénom, notes pour
différentes matières, et nombre d'absences.
2.Traitement :
○ Calculer la moyenne et déterminer la mention pour chaque
étudiant.
3.Affichage :
○ Afficher la liste des étudiants triée alphabétiquement
par nom.
○ Afficher les étudiants ayant obtenu la mention "Bien".
○ Afficher les étudiants ayant trop d'absences (>5).
Exercice 7 : Système de Bibliothèque
Objectifs :
● Créer une classe Livre avec des attributs, des méthodes et
des règles métier spécifiques.
● Utiliser des concepts POO, des dates (LocalDate), et des
collections.
● Gérer des codes auto-générés et des filtres de recherche.
Attributs de la classe Livre :
● code (String auto-généré "LIV-XXXX", non modifiable).
● titre (String).
● auteur (String).
● estEmprunte (boolean).
● dateEmprunt (LocalDate).
● genre (String : Roman, SF, etc.).
Méthodes à implémenter :
1.Constructeurs :
○ Un constructeur avec arguments (titre, auteur, genre)
générant automatiquement le code.
2.Getters/Setters :
○ Getters pour tous les attributs.
○ Setters uniquement pour les champs modifiables (titre,
auteur, genre).
3.Méthodes fonctionnelles :
○ emprunter() : Marque le livre comme emprunté avec la
date du jour, vérifie sa disponibilité.
○ rendre() : Marque le livre comme disponible et
réinitialise la date d'emprunt.
○ estEnRetard() : Retourne true si l'emprunt dépasse 21
jours.
○ contientMotCle(String mot) : Vérifie si le titre ou
l'auteur contient le mot-clé (insensible à la casse).
○ compterParGenre(List<Livre> livres) : Retourne une
Map<String, Integer> avec le nombre de livres par genre.
4.Règles métier :
○ Un livre déjà emprunté ne peut pas être emprunté à
nouveau.
○ La date d'emprunt est la date système au moment de
l'emprunt.
○ Un livre est considéré en retard après 21 jours
d'emprunt.
Classe de test (Main) :
1.Saisie utilisateur :
○ Demander les informations des livres jusqu'à entrer
"TERMINER" comme titre.
○ Pour chaque livre, saisir titre, auteur, genre.
○ Proposer d'emprunter certains livres (oui/non) pour
simuler l'emprunt.
2.Traitement :
○ Marquer les livres comme empruntés selon les choix de
l'utilisateur.
○ Simuler des dates d'emprunt variées pour tester les
retards.
3.Affichage :
○ Afficher les livres de genre "SF" disponibles.
○ Afficher les livres en retard avec le nombre de jours de
retard.
○ Afficher le nombre total de livres par genre.
Exercice 8 : Gestion de Stock
Objectifs :
● Créer une classe Produit avec des attributs, des méthodes et
des règles métier spécifiques.
● Utiliser des concepts POO, des règles de calcul de prix et de
gestion de stock.
● Générer des références combinant plusieurs informations.
Attributs de la classe Produit :
● reference (String format "PROD-2023-XX", auto-généré, non
modifiable).
● libelle (String).
● categorie (String).
● prix (double).
● quantite (double).
● seuilAlerte (int, 5 par défaut).
Méthodes à implémenter :
1.Constructeurs :
○ Un constructeur sans arguments initialisant les
attributs par défaut.
○ Un constructeur avec arguments (libelle, categorie,
prix, quantite) générant automatiquement la référence.
○ Un constructeur avec arguments incluant seuilAlerte
personnalisé.
2.Getters/Setters :
○ Getters pour tous les attributs.
○ Setters uniquement pour les champs modifiables (libelle,
categorie, prix, quantite, seuilAlerte).
3.Méthodes fonctionnelles :
○ verifierStock() : Retourne true si la quantité est
inférieure au seuil d'alerte.
○ appliquerRemise(double pourcentage) : Applique une
remise sur le prix si quantite > 50.
○ genererReference() : Génère une référence combinant
année, catégorie et identifiant.
○ calculerValeurStock() : Retourne le prix total du stock
(prix × quantite).
4.Règles métier :
○ La référence doit combiner l'année courante, la
catégorie et un identifiant unique.
○ Les remises s'appliquent uniquement aux produits dont la
quantité dépasse 50 unités.
○ Le seuil d'alerte par défaut est 5 mais peut être
personnalisé.
Classe de test (Main) :
1.Saisie utilisateur :
○ Demander les informations des produits jusqu'à entrer
"STOP" comme libellé.
○ Pour chaque produit, saisir libellé, catégorie, prix,
quantité et seuil d'alerte optionnel.
2.Traitement :
○ Vérifier les produits dont le stock est inférieur au
seuil d'alerte.
○ Calculer le coût total du stock.
○ Appliquer 10% de remise aux produits ayant une quantité
> 50.
3.Affichage :
○ Afficher les produits à réapprovisionner (stock <
seuil).
○ Afficher le coût total du stock avant et après remises.
○ Afficher la liste des produits avec leur nouveau prix
après remise éventuelle.
Exercice 9 : Agenda Électronique
Objectifs :
● Créer une classe RendezVous avec des attributs, des méthodes
et des règles métier spécifiques.
● Utiliser des concepts POO, des dates (LocalDateTime), et des
durées.
● Gérer des conflits d'horaires et des filtres par type.
Attributs de la classe RendezVous :
● id (int auto-incrémenté, non modifiable).
● titre (String).
● lieu (String).
● dateHeure (LocalDateTime).
● duree (int en minutes).
● type (String : Pro/Perso).
Méthodes à implémenter :
1.Constructeurs :
○ Un constructeur sans arguments initialisant les
attributs par défaut.
○ Un constructeur avec arguments (titre, lieu, dateHeure,
duree, type) générant automatiquement l'id.
2.Getters/Setters :
○ Getters pour tous les attributs.
○ Setters uniquement pour les champs modifiables (titre,
lieu, dateHeure, duree, type).
3.Méthodes fonctionnelles :
○ chevauche(RendezVous autre) : Retourne true si les
plages horaires se superposent.
○ envoyerRappel() : Affiche "Rappel : [titre] à [heure]".
○ filtrerParType(List<RendezVous> rdvs, String type) :
Retourne une sous-liste des RDV du type spécifié.
○ estDansSemaine(LocalDate debut) : Vérifie si le RDV est
dans la semaine commençant à la date donnée.
4.Règles métier :
○ L'id est auto-incrémenté à chaque création.
○ Le type doit être soit "Pro" soit "Perso".
○ Deux RDV se chevauchent si leurs plages horaires ont une
intersection non vide.
Classe de test (Main) :
1.Saisie utilisateur :
○ Demander les informations des RDV jusqu'à entrer
"QUITTER" comme titre.
○ Pour chaque RDV, saisir titre, lieu, date et heure,
durée, type.
2.Traitement :
○ Déterminer la semaine courante.
○ Identifier les RDV professionnels de la semaine.
○ Détecter les conflits potentiels (chevauchements) entre
RDV.
3.Affichage :
○ Afficher les RDV professionnels de la semaine courante.
○ Afficher les paires de RDV en conflit.
○ Afficher un rappel pour le prochain RDV à venir.
Exercice 10 : Club de Sport
Objectifs :
● Créer une classe Membre avec des attributs, des méthodes et
des règles métier spécifiques.
● Utiliser des concepts POO, des dates (Date), et des calculs
automatiques.
● Gérer des numéros de licence uniques et des cotisations
variables.
Attributs de la classe Membre :
● numeroLicence (String "CLUB-2023-NNN", auto-généré, non
modifiable).
● nom (String).
● statut (String : Étudiant/Adulte).
● dateInscription (Date).
● cotisation (double, calculée automatiquement).
Méthodes à implémenter :
1.Constructeurs :
○ Un constructeur sans arguments initialisant les
attributs par défaut.
○ Un constructeur avec arguments (nom, statut) générant
automatiquement le numéro de licence et la date
d'inscription (date du jour).
2.Getters/Setters :
○ Getters pour tous les attributs.
○ Setters uniquement pour les champs modifiables (nom,
statut).
3.Méthodes fonctionnelles :
○ calculerCotisation() : Calcule la cotisation (50€ pour
Adulte, 40€ pour Étudiant).
○ estValide() : Retourne true si l'inscription date de
moins d'un an.
○ compterParStatut(List<Membre> membres) : Retourne une
Map avec le nombre de membres par statut.
○ calculerPourcentageEtudiants(List<Membre> membres) :
Calcule le pourcentage d'étudiants parmi les membres.
4.Règles métier :
○ Le numéro de licence est généré automatiquement avec
l'année courante et un numéro séquentiel.
○ La cotisation est calculée en fonction du statut
(Étudiant/Adulte).
○ La date d'inscription est la date système au moment de
la création.
○ Une licence est valide pendant un an à partir de la date
d'inscription.
Classe de test (Main) :
1.Saisie utilisateur :
○ Demander les informations des membres jusqu'à entrer
"FIN" comme nom.
○ Pour chaque membre, saisir nom, statut.
○ Possibilité de simuler des dates d'inscription
antérieures pour tester la validité.
2.Traitement :
○ Calculer la cotisation pour chaque membre.
○ Vérifier la validité des licences.
○ Calculer le montant total des cotisations.
○ Calculer le pourcentage d'étudiants.
3.Affichage :
○ Afficher les membres avec licence expirée.
○ Afficher le montant total des cotisations.
○ Afficher le pourcentage d'étudiants parmi les membres.